internal static void WriteNamespaces(TextGenerator writer)
{
writer.WriteLine("using pb = global::Google.ProtocolBuffers;");
writer.WriteLine("using pbc = global::Google.ProtocolBuffers.Collections;");
writer.WriteLine("using pbd = global::Google.ProtocolBuffers.Descriptors;");
writer.WriteLine("using scg = global::System.Collections.Generic;");
}
public CSharpMarshalContext(Driver driver)
: base(driver)
{
Kind = CSharpMarshalKind.Unknown;
ArgumentPrefix = new TextGenerator();
Cleanup = new TextGenerator();
}
public void GenerateBuilderMembers(TextGenerator writer)
{
// Note: We can return the original list here, because we make it unmodifiable when we build
writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return result.{0}_; }}", Name);
writer.WriteLine("}");
writer.WriteLine("public int {0}Count {{", PropertyName);
writer.WriteLine(" get {{ return result.{0}Count; }}", PropertyName);
writer.WriteLine("}");
writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, PropertyName);
writer.WriteLine(" return result.Get{0}(index);", PropertyName);
writer.WriteLine("}");
writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", PropertyName, TypeName);
AddNullCheck(writer);
writer.WriteLine(" result.{0}_[index] = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Add{0}({1} value) {{", PropertyName, TypeName);
AddNullCheck(writer);
writer.WriteLine(" result.{0}_.Add(value);", Name, TypeName);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", PropertyName, TypeName);
writer.WriteLine(" base.AddRange(values, result.{0}_);", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Clear{0}() {{", PropertyName);
writer.WriteLine(" result.{0}_.Clear();", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public void GenerateBuilderMembers(TextGenerator writer)
{
AddDeprecatedFlag(writer);
writer.WriteLine("public bool Has{0} {{", PropertyName);
writer.WriteLine(" get {{ return result.has{0}; }}", PropertyName);
writer.WriteLine("}");
AddPublicMemberAttributes(writer);
writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return result.{0}; }}", PropertyName);
writer.WriteLine(" set {{ Set{0}(value); }}", PropertyName);
writer.WriteLine("}");
AddPublicMemberAttributes(writer);
writer.WriteLine("public Builder Set{0}({1} value) {{", PropertyName, TypeName);
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" result.has{0} = true;", PropertyName);
writer.WriteLine(" result.{0}_ = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public Builder Clear{0}() {{", PropertyName);
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" result.has{0} = false;", PropertyName);
writer.WriteLine(" result.{0}_ = {1};", Name, DefaultValue);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public void GenerateSerializedSizeCode(TextGenerator writer)
{
writer.WriteLine("if (Has{0}) {{", PropertyName);
writer.WriteLine(" size += pb::CodedOutputStream.Compute{0}Size({1}, {2});",
CapitalizedTypeName, Number, PropertyName);
writer.WriteLine("}");
}
public MarshalContext(Driver driver)
{
Driver = driver;
SupportBefore = new TextGenerator();
Return = new TextGenerator();
MarshalVarPrefix = string.Empty;
}
public void GenerateBuilderMembers(TextGenerator writer)
{
// Note: We can return the original list here, because we make it unmodifiable when we build
// We return it via IPopsicleList so that collection initializers work more pleasantly.
writer.WriteLine("public pbc::IPopsicleList<{0}> {1}List {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return result.{0}_; }}", Name);
writer.WriteLine("}");
writer.WriteLine("public int {0}Count {{", PropertyName);
writer.WriteLine(" get {{ return result.{0}Count; }}", PropertyName);
writer.WriteLine("}");
writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, PropertyName);
writer.WriteLine(" return result.Get{0}(index);", PropertyName);
writer.WriteLine("}");
writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", PropertyName, TypeName);
writer.WriteLine(" result.{0}_[index] = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Add{0}({1} value) {{", PropertyName, TypeName);
writer.WriteLine(" result.{0}_.Add(value);", Name, TypeName);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", PropertyName, TypeName);
writer.WriteLine(" base.AddRange(values, result.{0}_);", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Clear{0}() {{", PropertyName);
writer.WriteLine(" result.{0}_.Clear();", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public void GenerateBuilderMembers(TextGenerator writer)
{
// Note: We can return the original list here, because we make it unmodifiable when we build
// We return it via IPopsicleList so that collection initializers work more pleasantly.
AddDeprecatedFlag(writer);
writer.WriteLine("public pbc::IPopsicleList<{0}> {1}List {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return PrepareBuilder().{0}_; }}", Name);
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public int {0}Count {{", PropertyName);
writer.WriteLine(" get {{ return result.{0}Count; }}", PropertyName);
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, PropertyName);
writer.WriteLine(" return result.Get{0}(index);", PropertyName);
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", PropertyName, TypeName);
AddNullCheck(writer);
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" result.{0}_[index] = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
// Extra overload for builder (just on messages)
AddDeprecatedFlag(writer);
writer.WriteLine("public Builder Set{0}(int index, {1}.Builder builderForValue) {{", PropertyName, TypeName);
AddNullCheck(writer, "builderForValue");
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" result.{0}_[index] = builderForValue.Build();", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public Builder Add{0}({1} value) {{", PropertyName, TypeName);
AddNullCheck(writer);
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" result.{0}_.Add(value);", Name, TypeName);
writer.WriteLine(" return this;");
writer.WriteLine("}");
// Extra overload for builder (just on messages)
AddDeprecatedFlag(writer);
writer.WriteLine("public Builder Add{0}({1}.Builder builderForValue) {{", PropertyName, TypeName);
AddNullCheck(writer, "builderForValue");
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" result.{0}_.Add(builderForValue.Build());", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", PropertyName, TypeName);
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" result.{0}_.Add(values);", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public Builder Clear{0}() {{", PropertyName);
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" result.{0}_.Clear();", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public Block(int kind)
{
Kind = kind;
Blocks = new List<Block>();
Text = new TextGenerator();
hasIndentChanged = false;
isSubBlock = false;
}
public void GenerateMembers(TextGenerator writer) {
writer.WriteLine("private bool has{0};", PropertyName);
writer.WriteLine("private {0} {1}_ = {2};", TypeName, Name, DefaultValue);
writer.WriteLine("public bool Has{0} {{", PropertyName);
writer.WriteLine(" get {{ return has{0}; }}", PropertyName);
writer.WriteLine("}");
writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return {0}_; }}", Name);
writer.WriteLine("}");
}
public CompanyMakerState(DwarfGame game, GameStateManager stateManager)
: base(game, "CompanyMakerState", stateManager)
{
CompanyName = DefaultName;
CompanyMotto = DefaultMotto;
CompanyLogo = DefaultLogo;
CompanyColor = DefaultColor;
EdgePadding = 32;
Input = new InputManager();
Drawer = new Drawer2D(Game.Content, Game.GraphicsDevice);
TextGenerator = new TextGenerator();
}
public virtual void LayoutText(string content)
{
this.content = content.Trim();
Canvas.ForceUpdateCanvases();
TextGenerator generator = new TextGenerator();
TextGenerationSettings settings = text.GetGenerationSettings(new Vector2(rectTransform.sizeDelta.x, 0));
settings.updateBounds = true;
settings.scaleFactor = 1;
generator.Populate(content, settings);
layoutElement.preferredHeight = generator.rectExtents.height;
}
public void GenerateParsingCode(TextGenerator writer)
{
// TODO(jonskeet): Make a more efficient way of doing this
writer.WriteLine("int rawValue = input.ReadEnum();");
writer.WriteLine("if (!global::System.Enum.IsDefined(typeof({0}), rawValue)) {{", TypeName);
writer.WriteLine(" if (unknownFields == null) {"); // First unknown field - create builder now
writer.WriteLine(" unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);");
writer.WriteLine(" }");
writer.WriteLine(" unknownFields.MergeVarintField({0}, (ulong) rawValue);", Number);
writer.WriteLine("} else {");
writer.WriteLine(" {0} = ({1}) rawValue;", PropertyName, TypeName);
writer.WriteLine("}");
}
// Resize input field as new lines get added
private void ResizeInput(string iText)
{
string fullText = text;
Vector2 extents = textComponent.rectTransform.rect.size;
var settings = textComponent.GetGenerationSettings(extents);
settings.generateOutOfBounds = false;
var prefHeight = new TextGenerator().GetPreferredHeight(fullText, settings) + 16;
if(prefHeight > textComponent.rectTransform.rect.height - 16 || prefHeight < textComponent.rectTransform.rect.height + 16) {
rectTransform.sizeDelta = new Vector2(rectTransform.sizeDelta.x, prefHeight);
}
}
public void GenerateMembers(TextGenerator writer)
{
writer.WriteLine("private bool has{0};", PropertyName);
writer.WriteLine("private {0} {1}_{2};", TypeName, Name, HasDefaultValue ? " = " + DefaultValue : "");
AddDeprecatedFlag(writer);
writer.WriteLine("public bool Has{0} {{", PropertyName);
writer.WriteLine(" get {{ return has{0}; }}", PropertyName);
writer.WriteLine("}");
AddPublicMemberAttributes(writer);
writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return {0}_; }}", Name);
writer.WriteLine("}");
}
public void GenerateParsingCode(TextGenerator writer)
{
writer.WriteLine("{0}.Builder subBuilder = {0}.CreateBuilder();", TypeName);
writer.WriteLine("if (Has{0}) {{", PropertyName);
writer.WriteLine(" subBuilder.MergeFrom({0});", PropertyName);
writer.WriteLine("}");
if (Descriptor.FieldType == FieldType.Group) {
writer.WriteLine("input.ReadGroup({0}, subBuilder, extensionRegistry);", Number);
} else {
writer.WriteLine("input.ReadMessage(subBuilder, extensionRegistry);");
}
writer.WriteLine("{0} = subBuilder.BuildPartial();", PropertyName);
}
public void GenerateBuilderMembers(TextGenerator writer)
{
AddDeprecatedFlag(writer);
writer.WriteLine("public bool Has{0} {{", PropertyName);
writer.WriteLine(" get {{ return result.has{0}; }}", PropertyName);
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return result.{0}; }}", PropertyName);
writer.WriteLine(" set {{ Set{0}(value); }}", PropertyName);
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public Builder Set{0}({1} value) {{", PropertyName, TypeName);
AddNullCheck(writer);
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" result.has{0} = true;", PropertyName);
writer.WriteLine(" result.{0}_ = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public Builder Set{0}({1}.Builder builderForValue) {{", PropertyName, TypeName);
AddNullCheck(writer, "builderForValue");
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" result.has{0} = true;", PropertyName);
writer.WriteLine(" result.{0}_ = builderForValue.Build();", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public Builder Merge{0}({1} value) {{", PropertyName, TypeName);
AddNullCheck(writer);
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" if (result.has{0} &&", PropertyName);
writer.WriteLine(" result.{0}_ != {1}) {{", Name, DefaultValue);
writer.WriteLine(" result.{0}_ = {1}.CreateBuilder(result.{0}_).MergeFrom(value).BuildPartial();", Name,
TypeName);
writer.WriteLine(" } else {");
writer.WriteLine(" result.{0}_ = value;", Name);
writer.WriteLine(" }");
writer.WriteLine(" result.has{0} = true;", PropertyName);
writer.WriteLine(" return this;");
writer.WriteLine("}");
AddDeprecatedFlag(writer);
writer.WriteLine("public Builder Clear{0}() {{", PropertyName);
writer.WriteLine(" PrepareBuilder();");
writer.WriteLine(" result.has{0} = false;", PropertyName);
writer.WriteLine(" result.{0}_ = null;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public void GenerateMembers(TextGenerator writer) {
writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name);
writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return {0}_; }}", Name);
writer.WriteLine("}");
// TODO(jonskeet): Redundant API calls? Possibly - include for portability though. Maybe create an option.
writer.WriteLine("public int {0}Count {{", PropertyName);
writer.WriteLine(" get {{ return {0}_.Count; }}", Name);
writer.WriteLine("}");
writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, PropertyName);
writer.WriteLine(" return {0}_[index];", Name);
writer.WriteLine("}");
}
void Start()
{
TextGenerationSettings settings = new TextGenerationSettings();
settings.textAnchor = TextAnchor.MiddleCenter;
settings.color = Color.red;
settings.generationExtents = extents;
settings.pivot = Vector2.zero;
settings.richText = true;
settings.font = font;
settings.fontSize = 32;
settings.resizeTextMinSize = resizeTextMinSize;
settings.resizeTextMaxSize = resizeTextMaxSize;
settings.fontStyle = FontStyle.Normal;
settings.verticalOverflow = VerticalWrapMode.Overflow;
TextGenerator generator = new TextGenerator();
generator.Populate("I am a string", settings);
Debug.Log("I generated: " + generator.vertexCount + " verts!");
}
public void ResizeToText() {
string fullText = _textField.text;
Vector2 extents = _textField.rectTransform.rect.size;
TextGenerationSettings settings = _textField.GetGenerationSettings(extents);
settings.generateOutOfBounds = false;
settings.updateBounds = true;
float genHeight = new TextGenerator().GetPreferredHeight(fullText, settings);
float windowHeight = _windowTransform.rect.height;
if (genHeight < windowHeight) {
genHeight = windowHeight;
_scrollbar.value = 1f;
_scrollbar.size = 1f;
_scrollbar.numberOfSteps = 0;
} else {
_scrollbar.value = 0f;
}
_textField.GetComponent<RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, genHeight);
}
public void GenerateMembers(TextGenerator writer)
{
if (Descriptor.IsPacked && Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) {
writer.WriteLine("private int {0}MemoizedSerializedSize;", Name);
}
writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name);
writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return pbc::Lists.AsReadOnly({0}_); }}", Name);
writer.WriteLine("}");
// TODO(jonskeet): Redundant API calls? Possibly - include for portability though. Maybe create an option.
writer.WriteLine("public int {0}Count {{", PropertyName);
writer.WriteLine(" get {{ return {0}_.Count; }}", Name);
writer.WriteLine("}");
writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, PropertyName);
writer.WriteLine(" return {0}_[index];", Name);
writer.WriteLine("}");
}
public void GenerateBuilderMembers(TextGenerator writer)
{
writer.WriteLine("public bool Has{0} {{", PropertyName);
writer.WriteLine(" get {{ return result.Has{0}; }}", PropertyName);
writer.WriteLine("}");
writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return result.{0}; }}", PropertyName);
writer.WriteLine(" set {{ Set{0}(value); }}", PropertyName);
writer.WriteLine("}");
writer.WriteLine("public Builder Set{0}({1} value) {{", PropertyName, TypeName);
writer.WriteLine(" result.has{0} = true;", PropertyName);
writer.WriteLine(" result.{0}_ = value;", Name);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine("public Builder Clear{0}() {{", PropertyName);
writer.WriteLine(" result.has{0} = false;", PropertyName);
writer.WriteLine(" result.{0}_ = {1};", Name, DefaultValue);
writer.WriteLine(" return this;");
writer.WriteLine("}");
}
public void Generate(TextGenerator writer)
{
if (Descriptor.File.CSharpOptions.ClsCompliance && GetFieldConstantName(Descriptor).StartsWith("_"))
{
writer.WriteLine("[global::System.CLSCompliant(false)]");
}
writer.WriteLine("public const int {0} = {1};", GetFieldConstantName(Descriptor), Descriptor.FieldNumber);
if (UseLiteRuntime)
{
if (Descriptor.MappedType == MappedType.Message && Descriptor.MessageType.Options.MessageSetWireFormat)
{
throw new ArgumentException(
"option message_set_wire_format = true; is not supported in Lite runtime extensions.");
}
if (!Descriptor.IsCLSCompliant && Descriptor.File.CSharpOptions.ClsCompliance)
{
writer.WriteLine("[global::System.CLSCompliant(false)]");
}
writer.WriteLine("{0} static pb::{4}<{1}, {2}> {3};", ClassAccessLevel, extends, type, name,
Descriptor.IsRepeated ? "GeneratedRepeatExtensionLite" : "GeneratedExtensionLite");
}
else if (Descriptor.IsRepeated)
{
if (!Descriptor.IsCLSCompliant && Descriptor.File.CSharpOptions.ClsCompliance)
{
writer.WriteLine("[global::System.CLSCompliant(false)]");
}
writer.WriteLine("{0} static pb::GeneratedExtensionBase<scg::IList<{1}>> {2};", ClassAccessLevel, type,
name);
}
else
{
if (!Descriptor.IsCLSCompliant && Descriptor.File.CSharpOptions.ClsCompliance)
{
writer.WriteLine("[global::System.CLSCompliant(false)]");
}
writer.WriteLine("{0} static pb::GeneratedExtensionBase<{1}> {2};", ClassAccessLevel, type, name);
}
}
public PToolTip(Transform _Background) : base(_Background)
{
InitializeControls <Text>();
GeneratorForLayout = new TextGenerator();
Close();
}
/// <summary>
/// Generates code for a particular file. All dependencies must
/// already have been resolved.
/// </summary>
private void Generate(FileDescriptor descriptor)
{
UmbrellaClassGenerator ucg = new UmbrellaClassGenerator(descriptor);
using (TextWriter textWriter = File.CreateText(GetOutputFile(descriptor))) {
TextGenerator writer = new TextGenerator(textWriter);
ucg.Generate(writer);
}
}
public override void Construct()
{
MinimumSize = new Point(1024, 128 + 6);
ScreenshotWidget = AddChild(new Widget()
{
MinimumSize = new Point(128, 128),
AutoLayout = AutoLayout.DockLeft,
Text = Item.Screenshot == null ? "No image" : "",
Font = "font8",
Border = "border-one"
});
var rightContent = AddChild(new Widget()
{
AutoLayout = AutoLayout.DockLeft,
MinimumSize = new Point(1024, 128),
InteriorMargin = new Margin(10, 10, 10, 10)
});
var title = rightContent.AddChild(new Widget()
{
Text = Item.Name,
Font = "font16",
AutoLayout = AutoLayout.DockTop,
});
rightContent.AddChild(new Widget()
{
Text = TextGenerator.AgeToString(Item.Age),
Font = "font8",
AutoLayout = AutoLayout.DockTop
});
if (!String.IsNullOrEmpty(Item.Valid))
{
rightContent.AddChild(new Widget()
{
Text = String.Format("(Invalid save: {0})", Item.Valid),
Font = "font8",
AutoLayout = AutoLayout.DockTop
});
}
var buttonContainer = rightContent.AddChild(new Widget()
{
MinimumSize = new Point(64, 32),
AutoLayout = AutoLayout.DockBottom
});
if (String.IsNullOrEmpty(Item.Valid))
{
LoadButton = buttonContainer.AddChild(new Gui.Widgets.Button()
{
Text = "Load",
AutoLayout = AutoLayout.DockLeft,
Border = "border-thin",
InteriorMargin = new Margin(0, 0, 3, 3),
Tooltip = "Click to load this save file"
});
}
DeleteButton = buttonContainer.AddChild(new Gui.Widgets.Button()
{
Text = "Delete",
AutoLayout = AutoLayout.DockLeft,
Border = "border-thin",
InteriorMargin = new Margin(0, 0, 3, 3),
Tooltip = "Click to delete this save file"
});
InteriorMargin = new Margin(3, 3, 3, 3);
base.Construct();
}
private void GenerateCommonBuilderMethods(TextGenerator writer)
{
writer.WriteLine("{0} Builder() {{}}", ClassAccessLevel);
writer.WriteLine();
writer.WriteLine("{0} result = new {0}();", ClassName);
writer.WriteLine();
writer.WriteLine("protected override {0} MessageBeingBuilt {{", ClassName);
writer.WriteLine(" get { return result; }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override Builder Clear() {");
writer.WriteLine(" result = new {0}();", ClassName);
writer.WriteLine(" return this;");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override Builder Clone() {");
writer.WriteLine(" return new Builder().MergeFrom(result);");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override pbd::MessageDescriptor DescriptorForType {");
writer.WriteLine(" get {{ return {0}.Descriptor; }}", ClassName);
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName);
writer.WriteLine(" get {{ return {0}.DefaultInstance; }}", ClassName);
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override {0} BuildPartial() {{", ClassName);
writer.Indent();
foreach (FieldDescriptor field in Descriptor.Fields)
{
SourceGenerators.CreateFieldGenerator(field).GenerateBuildingCode(writer);
}
writer.WriteLine("{0} returnMe = result;", ClassName);
writer.WriteLine("result = null;");
writer.WriteLine("return returnMe;");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED)
{
writer.WriteLine("public override Builder MergeFrom(pb::IMessage other) {");
writer.WriteLine(" if (other is {0}) {{", ClassName);
writer.WriteLine(" return MergeFrom(({0}) other);", ClassName);
writer.WriteLine(" } else {");
writer.WriteLine(" base.MergeFrom(other);");
writer.WriteLine(" return this;");
writer.WriteLine(" }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override Builder MergeFrom({0} other) {{", ClassName);
// Optimization: If other is the default instance, we know none of its
// fields are set so we can skip the merge.
writer.Indent();
writer.WriteLine("if (other == {0}.DefaultInstance) return this;", ClassName);
foreach (FieldDescriptor field in Descriptor.Fields)
{
SourceGenerators.CreateFieldGenerator(field).GenerateMergingCode(writer);
}
// if message type has extensions
if (Descriptor.Proto.ExtensionRangeCount > 0)
{
writer.WriteLine(" this.MergeExtensionFields(other);");
}
writer.WriteLine("this.MergeUnknownFields(other.UnknownFields);");
writer.WriteLine("return this;");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
}
private static void GenerateSerializeOneExtensionRange(TextGenerator writer,
DescriptorProto.Types.ExtensionRange extensionRange)
{
writer.WriteLine("extensionWriter.WriteUntil({0}, output);", extensionRange.End);
}
public static string GetRandomWorldName()
{
List <List <string> > templates = TextGenerator.GetAtoms(ContentPaths.Text.Templates.worlds);
return(TextGenerator.GenerateRandom(templates));
}
void UpdatePreferredValues(TextGenerationSettings tgs)
{
m_PreferredSize = TextGenerator.GetPreferredValues(tgs, layoutTextInfo);
}
public override void WriteHash(TextGenerator writer)
{
writer.WriteLine("if (has{0}) hash ^= {1}_.GetHashCode();", PropertyName, Name);
}
// Use Awake() to initialize field variables.
public void Awake()
{
// Create a Text UI element
m_textComponent = this.gameObject.AddComponent <Text>();
m_textGen = new TextGenerator();
Vector2 extents = new Vector2(0, 100);
m_generationSettings = m_textComponent.GetGenerationSettings(extents);
string sampleText = "_CeilingCirculationWeight";
m_paramTextWidth = m_textGen.GetPreferredWidth(sampleText, m_generationSettings);
m_paramTextHeight = m_textGen.GetPreferredHeight(sampleText, m_generationSettings);
Debug.Log("CommHub:" + this.gameObject);
m_canvasObj = this.gameObject.transform.GetChild(0).gameObject;
Debug.Log("Canvas Obj:" + m_canvasObj);
//m_canvas.worldCamera = GameObject.Find("EventCamera").GetComponent<Camera>();
m_canvas = m_canvasObj.GetComponent <Canvas>(); // == this.gameObject.GetComponent<Canvas>()
//Unity UI was an issue.Screen Space Overlay captures data from the primary display when setting up the UI on secondary.
// So things get out of position and scale etc.
//I set the Secondary Displays UI to Screenspace Camera instead.and ensured that camera 2 existed and had DISPLAY2 set.
Debug.Log("Target Display of the Event Camera=");
Debug.Log(m_canvas.worldCamera.targetDisplay);
// m_canvas.worldCamera.targetDisplay = 1;
// targetDisplay is index starting from 0; different from that of the inspector
//Debug.Log("Changed Target Display of the Event Camera=");
//Debug.Log(m_canvas.worldCamera.targetDisplay);
//https://stackoverflow.com/questions/43614662/unity-change-the-display-camera-for-the-scene-and-the-target-display-in-the-can
Debug.Log("Screen Current Resolution (The native best resolution) =");
Debug.Log(Screen.currentResolution);
Debug.Log("Target Display of Canvas [Screen Space-Overlay mode]=");
Debug.Log(m_canvas.targetDisplay);
Debug.Log("Scale Factor of Canvas [Screen Space-Overlay mode]=");
Debug.Log(m_canvas.scaleFactor);
// m_canvas.targetDisplay = 2;
//Debug.Log("Changed Target Display of Canvas [Screen Space-Overlay mode]=");
//Debug.Log(m_canvas.targetDisplay);
Debug.Log("[init] current canvas(screen) =");
Debug.Log(m_canvas.pixelRect);
m_canvasRectTransform = m_canvas.GetComponent <RectTransform>(); // used in onGUI() uses display 1 (primary display)
m_distanceToCamera = m_canvas.planeDistance;
MyIO.DebugLog("The Screen (Gameview) =");
MyIO.DebugLog(Screen.width + "x" + Screen.height);
MyIO.DebugLog("The aspect of the Screen (Gameview, Display 2)=");
MyIO.DebugLog((float)Screen.width / (float)Screen.height);
MyIO.DebugLog("The aspect of the Canvas (Screen Space - Camera Mode)=");
MyIO.DebugLog(m_canvas.pixelRect);
SetupButtonGUI();
} // Awake()
public void GenerateBuildingCode(TextGenerator writer)
{
writer.WriteLine("result.{0}_.MakeReadOnly();", Name);
}
public static Rect CalcSizeFromText(XdObjectJson xdObject)
{
var font = xdObject.Style.Font;
var fontSize = font.Size;
var rawText = xdObject.Text.RawText;
var position = Vector2.zero;
var findFont = AssetDatabase.FindAssets($"{font.PostscriptName} t:Font")
.Select(guid => AssetDatabase.GUIDToAssetPath(guid))
.Select(path => AssetDatabase.LoadAssetAtPath <Object>(path))
.OfType <Font>()
.ToArray();
var fontAsset = findFont.FirstOrDefault();
if (fontAsset == null)
{
Debug.LogWarning($"{font.PostscriptName} is not found in project / name: {xdObject.Name}, text: {rawText}");
fontAsset = Resources.GetBuiltinResource <Font>("Arial.ttf");
}
var settings = new TextGenerationSettings
{
generationExtents = Vector2.zero,
textAnchor = TextAnchor.MiddleCenter,
alignByGeometry = false,
scaleFactor = 1.0f,
color = Color.white,
font = fontAsset,
pivot = Vector2.zero,
richText = false,
lineSpacing = 1.0f,
resizeTextForBestFit = false,
updateBounds = true,
horizontalOverflow = HorizontalWrapMode.Overflow,
verticalOverflow = VerticalWrapMode.Overflow
};
var scale = 1.0f;
if (fontAsset.dynamic)
{
settings.fontSize = Mathf.RoundToInt(fontSize);
settings.fontStyle = FontStyle.Normal;
}
else
{
scale = fontSize / fontAsset.fontSize;
}
position.y -= fontAsset.ascent * (fontSize / fontAsset.fontSize);
var textGenerator = new TextGenerator();
textGenerator.Populate(rawText, settings);
var preferredWidth = textGenerator.rectExtents.width;
var preferredHeight = textGenerator.rectExtents.height;
var width = preferredWidth * scale;
var height = preferredHeight * scale;
var size = new Vector2(width, height);
var lines = xdObject.Text.Paragraphs.SelectMany(x => x.Lines).ToArray();
var lineMinX = lines.Min(x => x[0].X); // xは1要素目にだけ入っている
var lineMinY = lines.SelectMany(l => l).Min(x => x.Y);
position.x += lineMinX;
position.y += lineMinY;
return(new Rect(position, size));
}
public void GenerateBuildingCode(TextGenerator writer)
{
// Nothing to do here for enum types
}
public void GenerateMergingCode(TextGenerator writer)
{
writer.WriteLine("if (other.Has{0}) {{", PropertyName);
writer.WriteLine(" {0} = other.{0};", PropertyName);
writer.WriteLine("}");
}
public void GenerateSerializedSizeCode(TextGenerator writer)
{
writer.WriteLine("{");
writer.Indent();
writer.WriteLine("int dataSize = 0;");
if (FixedSize == -1) {
writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, PropertyName);
writer.WriteLine(" dataSize += pb::CodedOutputStream.Compute{0}SizeNoTag(element);", CapitalizedTypeName, Number);
writer.WriteLine("}");
} else {
writer.WriteLine("dataSize = {0} * {1}_.Count;", FixedSize, Name);
}
writer.WriteLine("size += dataSize;");
int tagSize = CodedOutputStream.ComputeTagSize(Descriptor.FieldNumber);
if (Descriptor.IsPacked) {
writer.WriteLine("size += {0};", tagSize);
writer.WriteLine("size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);");
} else {
writer.WriteLine("size += {0} * {1}_.Count;", tagSize, Name);
}
// cache the data size for packed fields.
if (Descriptor.IsPacked) {
writer.WriteLine("{0}MemoizedSerializedSize = dataSize;", Name);
}
writer.Outdent();
writer.WriteLine("}");
}
public static void OverlayImage(CustomText currentMessage, ImageInfo imageInfo)
{
CachedSpriteData cachedTextureData = imageInfo.cachedSprite;
// If cachedTextureData is null, the emote will be overlayed at a later time once it's finished being cached
if (cachedTextureData == null || (cachedTextureData.sprite == null && cachedTextureData.animInfo == null))
{
return;
}
bool animatedEmote = cachedTextureData.animInfo != null;
foreach (int i in EmojiUtilities.IndexOfAll(currentMessage.text, Char.ConvertFromUtf32(imageInfo.swapChar)))
{
CustomImage image = null, shadow = null;
try
{
if (i > 0 && i < currentMessage.text.Count())
{
image = ChatHandler.Instance.imagePool.Alloc();
image.cachedTextureData = cachedTextureData;
image.spriteIndex = imageInfo.textureIndex;
image.imageType = imageInfo.imageType;
image.sprite = cachedTextureData.sprite;
image.preserveAspect = false;
if (image.sprite)
{
image.sprite.texture.wrapMode = TextureWrapMode.Clamp;
}
image.rectTransform.SetParent(currentMessage.rectTransform, false);
image.rectTransform.localScale = new Vector3(0.064f, 0.064f, 0.064f);
image.rectTransform.sizeDelta = new Vector2(cachedTextureData.width, cachedTextureData.height);
if (imageInfo.imageType == ImageType.Emoji || imageInfo.imageType == ImageType.Badge)
{
image.rectTransform.pivot = new Vector2(0, 0.21f);
}
else
{
image.rectTransform.pivot = new Vector2(0, 0.3f);
}
TextGenerator textGen = currentMessage.cachedTextGenerator;
Vector3 pos = new Vector3(textGen.verts[i * 4].position.x, textGen.verts[i * 4].position.y);
image.rectTransform.position = currentMessage.gameObject.transform.TransformPoint(pos / pixelsPerUnit + new Vector3(0, 0, -0.1f));
if (animatedEmote)
{
cachedTextureData.animInfo?.animData?.IncRefs();
image.material = cachedTextureData.animInfo.imageMaterial;
if (ChatConfig.instance.DrawShadows && cachedTextureData.animInfo.shadowMaterial != null)
{
// Add a shadow to our animated image (the regular unity shadows won't work with this material)
shadow = ChatHandler.Instance.imagePool.Alloc();
shadow.material = cachedTextureData.animInfo.shadowMaterial;
shadow.sprite = null;
shadow.spriteIndex = imageInfo.textureIndex;
shadow.imageType = imageInfo.imageType;
shadow.rectTransform.pivot = new Vector2(0, 0);
shadow.rectTransform.localScale = image.rectTransform.localScale;
shadow.rectTransform.SetParent(currentMessage.rectTransform, false);
shadow.rectTransform.position = image.rectTransform.position;
shadow.rectTransform.localPosition += new Vector3(0.6f, -0.6f, 0.05f);
shadow.enabled = true;
currentMessage.emoteRenderers.Add(shadow);
}
}
else
{
image.material = noGlowMaterialUI;
if (ChatConfig.instance.DrawShadows)
{
image.shadow.enabled = true;
}
}
image.enabled = true;
currentMessage.emoteRenderers.Add(image);
}
}
catch (Exception e)
{
if (image)
{
ChatHandler.Instance.imagePool.Free(image);
}
Plugin.Log($"Exception {e.ToString()} occured when trying to overlay emote at index {i.ToString()}!");
}
}
}
public override void WriteToString(TextGenerator writer)
{
writer.WriteLine("PrintField(\"{0}\", has{1}, {2}_, writer);", Descriptor.Name, PropertyName, Name);
}
public CSharpMarshalContext(BindingContext context)
: base(context)
{
ArgumentPrefix = new TextGenerator();
Cleanup = new TextGenerator();
}
public AppServiceClassStep([NotNull] TextGenerator textGenerator) : base(textGenerator)
{
}
void ResizeInput(string text)
{
// current text settings
TextGenerationSettings settings = InputField.textComponent.GetGenerationSettings(InputField.textComponent.rectTransform.rect.size);
settings.generateOutOfBounds = false;
// current text rect height
float currentHeight = InputField.textComponent.rectTransform.rect.height;
if (textGenerator == null)
{
textGenerator = new TextGenerator();
}
// preferred text rect height
float preferredHeight = (textGenerator.GetPreferredHeight(InputField.text, settings) / ScaleFactor) + VerticalOffset;
float defaultHeight;
// default text rect height (fit to scroll parent or expand to fit text)
if (scrollRect)
{
defaultHeight = ScrollRectTransform.rect.height;
}
else
{
defaultHeight = ((textGenerator.GetPreferredHeight("", settings) * textRows) / ScaleFactor) + VerticalOffset;
}
// force resize
if (currentHeight < preferredHeight || currentHeight > preferredHeight)
{
if (preferredHeight > defaultHeight)
{
if (ParentLayout)
{
InputElement.preferredHeight = preferredHeight;
}
else
{
Rect.sizeDelta = new Vector2(Rect.rect.width, preferredHeight);
}
}
else
{
if (ParentLayout)
{
InputElement.preferredHeight = defaultHeight;
}
else
{
Rect.sizeDelta = new Vector2(Rect.rect.width, defaultHeight);
}
}
}
else
{
if (ParentLayout)
{
InputElement.preferredHeight = defaultHeight;
}
else
{
Rect.sizeDelta = new Vector2(Rect.rect.width, defaultHeight);
}
}
// update scroll rect position
if (scrollRect)
{
StartCoroutine(ScrollMax());
}
}
private string ToRtlParagraph(string text)
{
List <string> lines = new List <string>();
string[] words = text.Split(' ');
text = "";
for (int i = 0; i < words.Length; i++)
{
text += RTL.GetText(words[i]) + " ";
}
float width = GetComponent <RectTransform>().sizeDelta.x;
bool ok = false;
int num = 0;
int tempI = 0;
while (!ok)
{
num++;
TextGenerationSettings setting = textUI.GetGenerationSettings(new Vector2(width - 10f, 20.0F));
TextGenerator generator = new TextGenerator();
generator.Populate(text, setting);
int maxSize = generator.characterCountVisible;
int size = 0;
bool end = false;
for (int i = tempI; i < words.Length; i++)
{
size += words[i].Length + 1;
if ((size - 1) > maxSize)
{
string line = "";
int lineSize = 0;
for (int j = tempI; j < i; j++)
{
line += (words[j] + " ");
lineSize += words[j].Length + 1;
}
lines.Add(line);
if (lineSize != text.Length)
{
text = text.Substring(lineSize, text.Length - lineSize);
}
else
{
text = "";
}
tempI = i;
break;
}
else if (i == words.Length - 1)
{
string line = "";
int lineSize = 0;
for (int j = tempI; j < i + 1; j++)
{
line += (words[j] + " ");
lineSize += words[j].Length + 1;
}
lines.Add(line);
end = true;
}
}
if (end)
{
ok = true;
}
if (num == 10)
{
ok = true;
}
}
text = "";
for (int i = 0; i < lines.Count; i++)
{
text += lines[i] + "\n";
}
return(text);
}
void CalcBoundsInfo(List <Vector3> listVertsPos, VertexHelper toFill, TextGenerationSettings settings)
{
#region 包围框
// 处理超链接包围框
foreach (var hrefInfo in _listHrefInfos)
{
hrefInfo.Boxes.Clear();
if (hrefInfo.StartIndex >= listVertsPos.Count)
{
continue;
}
// 将超链接里面的文本顶点索引坐标加入到包围框
var pos = listVertsPos[hrefInfo.StartIndex];
var bounds = new Bounds(pos, Vector3.zero);
for (int i = hrefInfo.StartIndex, m = hrefInfo.EndIndex; i < m; i++)
{
if (i >= listVertsPos.Count)
{
break;
}
pos = listVertsPos[i];
if (pos.x < bounds.min.x)
{
// 换行重新添加包围框
hrefInfo.Boxes.Add(new Rect(bounds.min, bounds.size));
bounds = new Bounds(pos, Vector3.zero);
}
else
{
bounds.Encapsulate(pos); // 扩展包围框
}
}
//添加包围盒
hrefInfo.Boxes.Add(new Rect(bounds.min, bounds.size));
}
#endregion
#region 添加下划线
TextGenerator underlineText = new TextGenerator();
underlineText.Populate("_", settings);
IList <UIVertex> tut = underlineText.verts;
foreach (var item in _listHrefInfos)
{
for (int i = 0; i < item.Boxes.Count; i++)
{
//计算下划线的位置
Vector3[] ulPos = new Vector3[4];
ulPos[0] = item.Boxes[i].position + new Vector2(0.0f, fontSize * 0.2f);
ulPos[1] = ulPos[0] + new Vector3(item.Boxes[i].width, 0.0f);
ulPos[2] = item.Boxes[i].position + new Vector2(item.Boxes[i].width, 0.0f);
ulPos[3] = item.Boxes[i].position;
//绘制下划线
for (int j = 0; j < 4; j++)
{
m_TempVerts[j] = tut[j];
m_TempVerts[j].color = Color.blue;
m_TempVerts[j].position = ulPos[j];
if (j == 3)
{
toFill.AddUIVertexQuad(m_TempVerts);
}
}
}
}
#endregion
}
public void Generate(TextGenerator writer)
{
writer.WriteLine("{0} sealed partial class {1} : pb::{2}Message<{1}, {1}.Builder> {{",
ClassAccessLevel, ClassName, Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated");
writer.Indent();
// Must call BuildPartial() to make sure all lists are made read-only
writer.WriteLine("private static readonly {0} defaultInstance = new Builder().BuildPartial();", ClassName);
writer.WriteLine("public static {0} DefaultInstance {{", ClassName);
writer.WriteLine(" get { return defaultInstance; }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName);
writer.WriteLine(" get { return defaultInstance; }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("protected override {0} ThisMessage {{", ClassName);
writer.WriteLine(" get { return this; }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public static pbd::MessageDescriptor Descriptor {");
writer.WriteLine(" get {{ return {0}.internal__{1}__Descriptor; }}", DescriptorUtil.GetFullUmbrellaClassName(Descriptor),
GetUniqueFileScopeIdentifier(Descriptor));
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("protected override pb::FieldAccess.FieldAccessorTable<{0}, {0}.Builder> InternalFieldAccessors {{", ClassName);
writer.WriteLine(" get {{ return {0}.internal__{1}__FieldAccessorTable; }}", DescriptorUtil.GetFullUmbrellaClassName(Descriptor),
GetUniqueFileScopeIdentifier(Descriptor));
writer.WriteLine("}");
writer.WriteLine();
// Extensions don't need to go in an extra nested type
WriteChildren(writer, null, Descriptor.Extensions);
if (Descriptor.EnumTypes.Count + Descriptor.NestedTypes.Count > 0)
{
writer.WriteLine("#region Nested types");
writer.WriteLine("public static class Types {");
writer.Indent();
WriteChildren(writer, null, Descriptor.EnumTypes);
WriteChildren(writer, null, Descriptor.NestedTypes);
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine("#endregion");
writer.WriteLine();
}
foreach (FieldDescriptor fieldDescriptor in Descriptor.Fields)
{
// Rats: we lose the debug comment here :(
SourceGenerators.CreateFieldGenerator(fieldDescriptor).GenerateMembers(writer);
writer.WriteLine();
}
if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED)
{
GenerateIsInitialized(writer);
GenerateMessageSerializationMethods(writer);
}
GenerateParseFromMethods(writer);
GenerateBuilder(writer);
}
public void reloadData()
{
this.removeAllElements();
RectTransform rtran = this.GetComponent <RectTransform>();
//align
if (alignType == RichAlignType.DESIGN_CENTER)
{
rtran.GetComponent <RectTransform>().pivot = new Vector2(0.5f, 0.5f);
}
else if (alignType == RichAlignType.LEFT_TOP)
{
rtran.GetComponent <RectTransform>().pivot = new Vector2(0f, 1f);
}
foreach (LRichElement elem in _richElements)
{
if (elem.type == RichType.TEXT)
{
LRichElementText elemText = elem as LRichElementText;
char[] _charArr = elemText.txt.ToCharArray();
TextGenerator gen = new TextGenerator();
foreach (char strChar in _charArr)
{
LRenderElement rendElem = new LRenderElement();
rendElem.type = RichType.TEXT;
rendElem.strChar = strChar.ToString();
rendElem.isOutLine = elemText.isOutLine;
rendElem.isUnderLine = elemText.isUnderLine;
rendElem.font = this.font;
rendElem.fontSize = elemText.fontSize;
rendElem.data = elemText.data;
rendElem.color = elemText.color;
TextGenerationSettings setting = new TextGenerationSettings();
setting.font = this.font;
setting.fontSize = elemText.fontSize;
setting.lineSpacing = 1;
setting.scaleFactor = 1;
setting.verticalOverflow = VerticalWrapMode.Overflow;
setting.horizontalOverflow = HorizontalWrapMode.Overflow;
rendElem.width = (int)gen.GetPreferredWidth(rendElem.strChar, setting);
rendElem.height = (int)gen.GetPreferredHeight(rendElem.strChar, setting);
_elemRenderArr.Add(rendElem);
}
}
else if (elem.type == RichType.IMAGE)
{
LRichElementImage elemImg = elem as LRichElementImage;
LRenderElement rendElem = new LRenderElement();
rendElem.type = RichType.IMAGE;
rendElem.path = elemImg.path;
rendElem.data = elemImg.data;
Sprite sp = LLoadBundle.GetInstance().LoadAsset(LGameConfig.WINDOW_BUNDLE, rendElem.path, typeof(Sprite)) as Sprite;
// Sprite sp = Resources.Load(rendElem.path,typeof(Sprite)) as Sprite;
rendElem.width = sp.texture.width;
rendElem.height = sp.texture.height;
_elemRenderArr.Add(rendElem);
}
else if (elem.type == RichType.ANIM)
{
LRichElementAnim elemAnim = elem as LRichElementAnim;
LRenderElement rendElem = new LRenderElement();
rendElem.type = RichType.ANIM;
rendElem.path = elemAnim.path;
rendElem.data = elemAnim.data;
rendElem.fs = elemAnim.fs;
Sprite sp = LLoadBundle.GetInstance().LoadAsset(LGameConfig.WINDOW_BUNDLE, rendElem.path + "/1", typeof(Sprite)) as Sprite;
// Sprite sp = Resources.Load(rendElem.path+"/1",typeof(Sprite)) as Sprite;
rendElem.width = sp.texture.width;
rendElem.height = sp.texture.height;
_elemRenderArr.Add(rendElem);
}
else if (elem.type == RichType.NEWLINE)
{
LRenderElement rendElem = new LRenderElement();
rendElem.isNewLine = true;
_elemRenderArr.Add(rendElem);
}
}
_richElements.Clear();
formarRenderers();
}
private void GenerateMessageSerializationMethods(TextGenerator writer)
{
List <FieldDescriptor> sortedFields = new List <FieldDescriptor>(Descriptor.Fields);
sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber));
List <ExtensionRange> sortedExtensions = new List <ExtensionRange>(Descriptor.Proto.ExtensionRangeList);
sortedExtensions.Sort((r1, r2) => (r1.Start.CompareTo(r2.Start)));
writer.WriteLine("public override void WriteTo(pb::CodedOutputStream output) {");
writer.Indent();
if (Descriptor.Proto.ExtensionRangeList.Count > 0)
{
writer.WriteLine("pb::ExtendableMessage<{0}, {0}.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);",
ClassName);
}
// Merge the fields and the extension ranges, both sorted by field number.
for (int i = 0, j = 0; i < Descriptor.Fields.Count || j < sortedExtensions.Count;)
{
if (i == Descriptor.Fields.Count)
{
GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]);
}
else if (j == sortedExtensions.Count)
{
GenerateSerializeOneField(writer, sortedFields[i++]);
}
else if (sortedFields[i].FieldNumber < sortedExtensions[j].Start)
{
GenerateSerializeOneField(writer, sortedFields[i++]);
}
else
{
GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]);
}
}
if (Descriptor.Proto.Options.MessageSetWireFormat)
{
writer.WriteLine("UnknownFields.WriteAsMessageSetTo(output);");
}
else
{
writer.WriteLine("UnknownFields.WriteTo(output);");
}
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("private int memoizedSerializedSize = -1;");
writer.WriteLine("public override int SerializedSize {");
writer.Indent();
writer.WriteLine("get {");
writer.Indent();
writer.WriteLine("int size = memoizedSerializedSize;");
writer.WriteLine("if (size != -1) return size;");
writer.WriteLine();
writer.WriteLine("size = 0;");
foreach (FieldDescriptor field in Descriptor.Fields)
{
SourceGenerators.CreateFieldGenerator(field).GenerateSerializedSizeCode(writer);
}
if (Descriptor.Proto.ExtensionRangeCount > 0)
{
writer.WriteLine("size += ExtensionsSerializedSize;");
}
if (Descriptor.Options.MessageSetWireFormat)
{
writer.WriteLine("size += UnknownFields.SerializedSizeAsMessageSet;");
}
else
{
writer.WriteLine("size += UnknownFields.SerializedSize;");
}
writer.WriteLine("memoizedSerializedSize = size;");
writer.WriteLine("return size;");
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
public void GenerateSerializedSizeCode(TextGenerator writer)
{
writer.WriteLine("if (has{0}) {{", PropertyName);
writer.WriteLine(" size += pb::CodedOutputStream.ComputeEnumSize({0}, (int) {1});", Number, PropertyName);
writer.WriteLine("}");
}
protected void _UnInitGenerator()
{
mGenerator = null;
}
public void Generate(TextGenerator writer)
{
if (Descriptor.File.CSharpOptions.AddSerializable)
{
writer.WriteLine("[global::System.SerializableAttribute()]");
}
writer.WriteLine("[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]");
writer.WriteLine("[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]");
writer.WriteLine("[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"{0}\", \"{1}\")]",
GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version);
writer.WriteLine("{0} sealed partial class {1} : pb::{2}Message{3}<{1}, {1}.Builder> {{",
ClassAccessLevel, ClassName,
Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated",
RuntimeSuffix);
writer.Indent();
if (Descriptor.File.CSharpOptions.GeneratePrivateCtor)
{
writer.WriteLine("private {0}() {{ }}", ClassName);
}
// Must call MakeReadOnly() to make sure all lists are made read-only
writer.WriteLine("private static readonly {0} defaultInstance = new {0}().MakeReadOnly();", ClassName);
if (OptimizeSpeed)
{
writer.WriteLine("private static readonly string[] _{0}FieldNames = new string[] {{ {2}{1}{2} }};",
NameHelpers.UnderscoresToCamelCase(ClassName), String.Join("\", \"", FieldNames),
FieldNames.Length > 0 ? "\"" : "");
List <string> tags = new List <string>();
foreach (string name in FieldNames)
{
tags.Add(WireFormat.MakeTag(Descriptor.FindFieldByName(name)).ToString());
}
writer.WriteLine("private static readonly uint[] _{0}FieldTags = new uint[] {{ {1} }};",
NameHelpers.UnderscoresToCamelCase(ClassName), String.Join(", ", tags.ToArray()));
}
writer.WriteLine("public static {0} DefaultInstance {{", ClassName);
writer.WriteLine(" get { return defaultInstance; }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName);
writer.WriteLine(" get { return DefaultInstance; }");
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("protected override {0} ThisMessage {{", ClassName);
writer.WriteLine(" get { return this; }");
writer.WriteLine("}");
writer.WriteLine();
if (!UseLiteRuntime)
{
writer.WriteLine("public static pbd::MessageDescriptor Descriptor {");
writer.WriteLine(" get {{ return {0}.internal__{1}__Descriptor; }}",
DescriptorUtil.GetFullUmbrellaClassName(Descriptor),
GetUniqueFileScopeIdentifier(Descriptor));
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine(
"protected override pb::FieldAccess.FieldAccessorTable<{0}, {0}.Builder> InternalFieldAccessors {{",
ClassName);
writer.WriteLine(" get {{ return {0}.internal__{1}__FieldAccessorTable; }}",
DescriptorUtil.GetFullUmbrellaClassName(Descriptor),
GetUniqueFileScopeIdentifier(Descriptor));
writer.WriteLine("}");
writer.WriteLine();
}
// Extensions don't need to go in an extra nested type
WriteChildren(writer, null, Descriptor.Extensions);
if (Descriptor.EnumTypes.Count + Descriptor.NestedTypes.Count > 0)
{
writer.WriteLine("#region Nested types");
writer.WriteLine("[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]");
writer.WriteLine("[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]");
writer.WriteLine("[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"{0}\", \"{1}\")]",
GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version);
writer.WriteLine("public static class Types {");
writer.Indent();
WriteChildren(writer, null, Descriptor.EnumTypes);
WriteChildren(writer, null, Descriptor.NestedTypes);
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine("#endregion");
writer.WriteLine();
}
foreach (FieldDescriptor fieldDescriptor in Descriptor.Fields)
{
if (Descriptor.File.CSharpOptions.ClsCompliance && GetFieldConstantName(fieldDescriptor).StartsWith("_"))
{
writer.WriteLine("[global::System.CLSCompliant(false)]");
}
// Rats: we lose the debug comment here :(
writer.WriteLine("public const int {0} = {1};", GetFieldConstantName(fieldDescriptor),
fieldDescriptor.FieldNumber);
CreateFieldGenerator(fieldDescriptor).GenerateMembers(writer);
writer.WriteLine();
}
if (OptimizeSpeed)
{
GenerateIsInitialized(writer);
GenerateMessageSerializationMethods(writer);
}
if (UseLiteRuntime)
{
GenerateLiteRuntimeMethods(writer);
}
GenerateParseFromMethods(writer);
GenerateBuilder(writer);
// Force the static initialization code for the file to run, since it may
// initialize static variables declared in this class.
writer.WriteLine("static {0}() {{", ClassName);
// We call object.ReferenceEquals() just to make it a valid statement on its own.
// Another option would be GetType(), but that causes problems in DescriptorProtoFile,
// where the bootstrapping is somewhat recursive - type initializers call
// each other, effectively. We temporarily see Descriptor as null.
writer.WriteLine(" object.ReferenceEquals({0}.Descriptor, null);",
DescriptorUtil.GetFullUmbrellaClassName(Descriptor));
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
protected void _InitGenerator(Text t)
{
mGenerator = t.cachedTextGeneratorForLayout;
mGenerationSetting = t.GetGenerationSettings(new Vector2(t.rectTransform.sizeDelta.x, 0));
}
private void GenerateMessageSerializationMethods(TextGenerator writer)
{
List <FieldDescriptor> sortedFields = new List <FieldDescriptor>(Descriptor.Fields);
sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber));
List <DescriptorProto.Types.ExtensionRange> sortedExtensions =
new List <DescriptorProto.Types.ExtensionRange>(Descriptor.Proto.ExtensionRangeList);
sortedExtensions.Sort((r1, r2) => (r1.Start.CompareTo(r2.Start)));
writer.WriteLine("public override void WriteTo(pb::ICodedOutputStream output) {");
writer.Indent();
// Make sure we've computed the serialized length, so that packed fields are generated correctly.
writer.WriteLine("int size = SerializedSize;");
writer.WriteLine("string[] field_names = _{0}FieldNames;", NameHelpers.UnderscoresToCamelCase(ClassName));
if (Descriptor.Proto.ExtensionRangeList.Count > 0)
{
writer.WriteLine(
"pb::ExtendableMessage{1}<{0}, {0}.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);",
ClassName, RuntimeSuffix);
}
// Merge the fields and the extension ranges, both sorted by field number.
for (int i = 0, j = 0; i < Descriptor.Fields.Count || j < sortedExtensions.Count;)
{
if (i == Descriptor.Fields.Count)
{
GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]);
}
else if (j == sortedExtensions.Count)
{
GenerateSerializeOneField(writer, sortedFields[i++]);
}
else if (sortedFields[i].FieldNumber < sortedExtensions[j].Start)
{
GenerateSerializeOneField(writer, sortedFields[i++]);
}
else
{
GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]);
}
}
if (!UseLiteRuntime)
{
if (Descriptor.Proto.Options.MessageSetWireFormat)
{
writer.WriteLine("UnknownFields.WriteAsMessageSetTo(output);");
}
else
{
writer.WriteLine("UnknownFields.WriteTo(output);");
}
}
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
writer.WriteLine("private int memoizedSerializedSize = -1;");
writer.WriteLine("public override int SerializedSize {");
writer.Indent();
writer.WriteLine("get {");
writer.Indent();
writer.WriteLine("int size = memoizedSerializedSize;");
writer.WriteLine("if (size != -1) return size;");
writer.WriteLine();
writer.WriteLine("size = 0;");
foreach (FieldDescriptor field in Descriptor.Fields)
{
CreateFieldGenerator(field).GenerateSerializedSizeCode(writer);
}
if (Descriptor.Proto.ExtensionRangeCount > 0)
{
writer.WriteLine("size += ExtensionsSerializedSize;");
}
if (!UseLiteRuntime)
{
if (Descriptor.Options.MessageSetWireFormat)
{
writer.WriteLine("size += UnknownFields.SerializedSizeAsMessageSet;");
}
else
{
writer.WriteLine("size += UnknownFields.SerializedSize;");
}
}
writer.WriteLine("memoizedSerializedSize = size;");
writer.WriteLine("return size;");
writer.Outdent();
writer.WriteLine("}");
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
public void GenerateSerializationCode(TextGenerator writer)
{
writer.WriteLine("if ({0}_.Count > 0) {{", Name);
writer.Indent();
if (Descriptor.IsPacked) {
writer.WriteLine("output.WriteRawVarint32({0});", WireFormat.MakeTag(Descriptor));
writer.WriteLine("output.WriteRawVarint32((uint) {0}MemoizedSerializedSize);", Name);
writer.WriteLine("foreach ({0} element in {1}_) {{", TypeName, Name);
writer.WriteLine(" output.Write{0}NoTag(element);", CapitalizedTypeName);
writer.WriteLine("}");
} else {
writer.WriteLine("foreach ({0} element in {1}_) {{", TypeName, Name);
writer.WriteLine(" output.Write{0}({1}, element);", CapitalizedTypeName, Number);
writer.WriteLine("}");
}
writer.Outdent();
writer.WriteLine("}");
}
private void GenerateSerializeOneField(TextGenerator writer, FieldDescriptor fieldDescriptor)
{
CreateFieldGenerator(fieldDescriptor).GenerateSerializationCode(writer);
}
void Start()
{
textGen = new TextGenerator();
}
public override void WriteEquals(TextGenerator writer)
{
writer.WriteLine("if (has{0} != other.has{0} || (has{0} && !{1}_.Equals(other.{1}_))) return false;",
PropertyName, Name);
}
public void GenerateParsingCode(TextGenerator writer)
{
if (Descriptor.IsPacked) {
writer.WriteLine("int length = input.ReadInt32();");
writer.WriteLine("int limit = input.PushLimit(length);");
writer.WriteLine("while (!input.ReachedLimit) {");
writer.WriteLine(" Add{0}(input.Read{1}());", PropertyName, CapitalizedTypeName);
writer.WriteLine("}");
writer.WriteLine("input.PopLimit(limit);");
} else {
writer.WriteLine("Add{0}(input.Read{1}());", PropertyName, CapitalizedTypeName);
}
}
public void GenerateMergingCode(TextGenerator writer)
{
writer.WriteLine("if (other.{0}_.Count != 0) {{", Name);
writer.WriteLine(" base.AddRange(other.{0}_, result.{0}_);", Name);
writer.WriteLine("}");
}
internal string GenerateCode(ProjectGenerationModel project, ProjectBinaryGenerationResult binaryGenerationResult)
{
var code = new TextGenerator();
UInt16 tempCount;
code.AppendLine($"#include \"{project.HeaderFileName}\"");
code.AppendLine($"#include <stdint.h>");
code.AppendLine("#include \"efsm_core.h\"");
if ((project.DebugMode == DebugMode.Desktop) && project.DebuggingEnabled)
{
code.AppendLine("#include \"stdio.h\"");
code.AppendLine("#include \"stdlib.h\"");
}
code.AppendLine();
var plural = false;
if (binaryGenerationResult.StateMachines.Count() > 1)
{
plural = true;
}
var notesString = "Notes\n\n" +
"The entire contents of this file are generated.\n" +
"Typically, the user should not modify files which are generated. Reasons for this are:\n\n" +
"-To avoid introducing errors.\n" +
"-Additions are lost every time a file is generated (this can be counterproductive).\n\n" +
"An important distinction to make is between a state machine definition, and an actual state machine.\n" +
"instance.\n\n" +
"In the EFSM environment, a state machine definition and a state machine instance are described as follows:\n\n" +
" State Machine Definition\n" +
" -A set of binary instructions (an array of 16 bit integers).\n" +
" -An array of pointers to the functions required for evaluating inputs.\n" +
" -An array of pointers to the functions required for performing actions.\n" +
" -Serves as a template for behavior.\n\n" +
" State Machine Instance\n" +
" -A variable of type EFSM_INSTANCE which has been initialized to a particular\n" +
" state machine definition.\n\n" +
"Contents of this File:\n\n" +
$"-Binary Structure {(plural?"Declarations":"Declaration")} ({(plural?"variables":"variable")} of type EFSM_BINARY)\n" +
$"-State Machine Instance Declaration{(plural?"s":"")} (variable{(plural?"s":"")} of type EFSM_INSTANCE)\n" +
"-Arrays for Function Pointers\n" +
$"-EFSM State Machine Binary {(plural?"Arrays":"Array")} ({(plural?"arrays":"an array")} of type uint16_t)\n" +
"-Initialization Function\n" +
"-EFSM Process Initialization Function (the only function in this file that should be called\n" +
" from user code)";
code.AppendLine("/*\n----------------------------------------------------------------------------------------------------");
code.AppendLine(notesString);
code.StandardSeparator($"Binary Structure Declaration{(plural?"s":"")}.\n\n" +
"Note:\n" +
"Reference to a set of binary instructions (an array of 16 bit integers) is \n" +
"\"wrapped\" in a corresponding structure of type EFSM_BINARY. In turn, it is the initialized\n" +
"instance of an EFSM_BINARY variable which is used by the EFSM execution mechanism. The \n" +
"typedef for the EFSM_BINARY struct may be found in efsm_core.h.");
foreach (var stateMachine in binaryGenerationResult.StateMachines)
{
if (stateMachine.StateMachine.IncludeInGeneration)
{
/*Declare the containing binary.*/
code.AppendLine(stateMachine.StateMachine.IncludeThisStateMachineDirectiveStart);
code.AppendLine($"EFSM_BINARY {stateMachine.StateMachine.BinaryContainerName};");
code.AppendLine(stateMachine.StateMachine.IncludeThisStateMachineDirectiveEnd);
}
}
code.StandardSeparator($"State Machine Instance{(plural ? "s" : "")}");
//Given every state machine definition, there are also state machine instances. Need to go through each state machine type, and create as many instances are required.
foreach (var stateMachineDefinition in binaryGenerationResult.StateMachines)
{
if (stateMachineDefinition.StateMachine.IncludeInGeneration)
{
code.AppendLine(stateMachineDefinition.StateMachine.IncludeThisStateMachineDirectiveStart);
code.AppendLine($"/*{stateMachineDefinition.StateMachine.IndexDefineName} Instances*/");
for (int i = 0; i < stateMachineDefinition.StateMachine.NumberOfInstances; i++)
{
code.AppendLine($"EFSM_INSTANCE {stateMachineDefinition.StateMachine.IndexDefineName.Replace(' ', '_')}_Instance_{i.ToString()};");
}
code.AppendLine(stateMachineDefinition.StateMachine.IncludeThisStateMachineDirectiveEnd);
code.AppendLine();
}
}
code.StandardSeparator($"State Machine Instance Array Declaration");
code.AppendLine($"EFSM_INSTANCE * efsmInstanceArray[{binaryGenerationResult.TotalNumberOfInstancesDefine}];");
code.StandardSeparator("Arrays for Function Pointers.\n\n" +
"Note:\n" +
"These arrays are used by the EFSM execution mechanism to access the functions which perform actions\n" +
"and evaluate inputs as required by the binary instructions for a given state machine definition.\n" +
"A given state machine definition will have a single array of pointers to input query functions, and\n" +
"a single array of pointers to action functions. They are initialized by calling the Initialization \n" +
"function (generated below), and are collectively referred to as the \"function reference arrays\" for \n" +
"a given state machine definition. ");
code.AppendLine();
tempCount = 0;
foreach (var stateMachine in binaryGenerationResult.StateMachines)
{
if (stateMachine.StateMachine.IncludeInGeneration)
{
code.AppendLine(stateMachine.StateMachine.IncludeThisStateMachineDirectiveStart);
code.AppendLine($"/*State Machine Definition \"{stateMachine.StateMachine.IndexDefineName}\"*/");
code.AppendLine();
code.AppendLine("/*Array for pointers to input query functions.*/");
/*Declare the input function reference array.*/
code.AppendLine($"uint8_t {stateMachine.StateMachine.InputReferenceArrayString};");
code.AppendLine();
code.AppendLine("/*Array for pointers to action functions.*/");
/*Declare the output action function reference array.*/
code.AppendLine($"void {stateMachine.StateMachine.ActionReferenceArrayString};");
code.AppendLine(stateMachine.StateMachine.IncludeThisStateMachineDirectiveEnd);
if (tempCount != (binaryGenerationResult.StateMachines.Length - 1))
{
code.AppendLine();
}
}
}
code.StandardSeparator($"EFSM Definition Binary {(plural?"Arrays":"Array")}");
foreach (var stateMachine in binaryGenerationResult.StateMachines)
{
if (stateMachine.StateMachine.IncludeInGeneration)
{
code.AppendLine(stateMachine.StateMachine.IncludeThisStateMachineDirectiveStart);
/*Create the state machine binary array.*/
int currentAddress = 0;
code.AppendLine();
code.AppendLine($"/* {stateMachine.StateMachine.Model.Name} Definition*/");
code.AppendLine($"uint16_t {stateMachine.StateMachine.LocalBinaryVariableName}[] = {{");
code.AppendLine();
using (code.Indent())
{
foreach (var segment in stateMachine.Segments)
{
code.AppendLine($"/*[{currentAddress}]: {segment.Source.GetComment()} */");
if (segment.Content.Length > 0)
{
foreach (var b in segment.Content)
{
//code.Append($"0x{Convert.ToString(b, 16).PadLeft(2, '0')}, ");
if (segment == stateMachine.Segments.Last())
{
code.Append($"{Convert.ToString(b, 10).PadLeft(0, '0')} ");
}
else
{
code.Append($"{Convert.ToString(b, 10).PadLeft(0, '0')}, ");
}
}
code.AppendLine();
code.AppendLine();
}
if (segment.Content != null)
{
currentAddress += segment.Content.Length;
}
}
}
code.AppendLine("};");
code.AppendLine(stateMachine.StateMachine.IncludeThisStateMachineDirectiveEnd);
code.AppendLine();
}
}
code.StandardSeparator("Initialization Function.\n\n" +
"Note:\n" +
"This function: \n" +
"-Initializes the efsmInstanceArray.\n" +
"-Initializes the EFSM_BINARY variables, as well as the function reference arrays for \n" +
" every state machine definition. \n" +
"-Makes calls to EFSM_InitializeInstance() function for the purpose of initializing the \n" +
" state machine instances themselves.");
code.AppendLine($"void EFSM_{project.ProjectName}_Init()\n{{");
code.Indent();
tempCount = 0;
/*Generate code to initialize instance array.*/
code.AppendLine("/*efsmInstanceArray initialization.*/");
code.AppendLine();
foreach (var efsmDef in binaryGenerationResult.StateMachines)
{
if (efsmDef.StateMachine.IncludeInGeneration)
{
code.AppendLine(efsmDef.StateMachine.IncludeThisStateMachineDirectiveStart);
for (int i = 0; i < efsmDef.StateMachine.NumberOfInstances; i++)
{
code.AppendLine($"efsmInstanceArray[{tempCount.ToString()}] = &{(efsmDef.StateMachine.IndexDefineName.Replace(' ', '_'))}_Instance_{i.ToString()};");
tempCount++;
}
code.AppendLine(efsmDef.StateMachine.IncludeThisStateMachineDirectiveEnd);
}
}
code.AppendLine();
tempCount = 0;
foreach (var stateMachine in binaryGenerationResult.StateMachines)
{
if (stateMachine.StateMachine.IncludeInGeneration)
{
code.AppendLine(stateMachine.StateMachine.IncludeThisStateMachineDirectiveStart);
/*Set up the binary.*/
code.AppendLine($"/*State Machine Definition \"{stateMachine.StateMachine.IndexDefineName}\" Initialization*/");
code.AppendLine();
code.AppendLine("/*Associate an array of binary instructions with an EFSM_BINARY structure.*/");
code.AppendLine($"{stateMachine.StateMachine.BinaryContainerName}.data = {stateMachine.StateMachine.LocalBinaryVariableName};");
code.AppendLine();
code.AppendLine("/*Initialize the input functions array.*/");
/*Set up the input reference array.*/
var numberOfInputs = stateMachine.StateMachine.Inputs.Length;
for (int inputIndex = 0; inputIndex < numberOfInputs; inputIndex++)
{
code.AppendLine($"{stateMachine.StateMachine.InputReferenceArrayName}[{inputIndex}] = &{stateMachine.StateMachine.Inputs[inputIndex].FunctionName};");
}
code.AppendLine();
code.AppendLine("/*Initialize the output functions array.*/");
/*Set up the action reference array.*/
var numberOfActions = stateMachine.StateMachine.Actions.Length;
for (int actionIndex = 0; actionIndex < numberOfActions; actionIndex++)
{
code.AppendLine($"{stateMachine.StateMachine.ActionReferenceArrayName}[{actionIndex}] = &{stateMachine.StateMachine.Actions[actionIndex].FunctionName};");
}
if (tempCount != (binaryGenerationResult.StateMachines.Length - 1))
{
code.AppendLine();
}
tempCount++;
code.AppendLine(stateMachine.StateMachine.IncludeThisStateMachineDirectiveEnd);
}
}
/*Now, need to generate code which initializes the instances themselves.*/
code.AppendLine();
code.AppendLine("/*Instance initializations.*/");
string argString;
foreach (var efsmDef in binaryGenerationResult.StateMachines)
{
if (efsmDef.StateMachine.IncludeInGeneration)
{
code.AppendLine(efsmDef.StateMachine.IncludeThisStateMachineDirectiveStart);
for (int i = 0; i < efsmDef.StateMachine.NumberOfInstances; i++)
{
argString = $"&{efsmDef.StateMachine.IndexDefineName.Replace(' ', '_')}_Instance_{i.ToString()}, " + //Current Instance
$"&{efsmDef.StateMachine.BinaryContainerName}, " + //Relevant Binary
$"{efsmDef.StateMachine.ActionReferenceArrayName}, " + //Actions array for relevant binary
$"{efsmDef.StateMachine.InputReferenceArrayName}, " + //Inputs array for relevant binary
$"{i.ToString()}"; //Instance of type index.
code.AppendLine($"EFSM_InitializeInstance({argString});");
}
code.AppendLine(efsmDef.StateMachine.IncludeThisStateMachineDirectiveEnd);
}
}
code.RemoveIndent();
code.AppendLine("}\n");
code.StandardSeparator("EFSM Process Initialization.");
code.AppendLine();
code.AppendLine("void EFSM_InitializeProcess()\n{");
code.Indent();
code.AppendLine($"EFSM_{project.ProjectName}_Init();");
code.RemoveIndent();
code.AppendLine("}");
code.AppendLine();
code.AppendLine("uint8_t IsEfsmInstancePresent(uint8_t index)");
code.AppendLine("{");
code.AddIndent();
code.AppendLine("switch(index)");
code.AppendLine("{");
code.AddIndent();
int tempInstanceArrayIndex = 0;
foreach (var efsmDef in binaryGenerationResult.StateMachines)
{
if (efsmDef.StateMachine.IncludeInGeneration)
{
for (int i = 0; i < efsmDef.StateMachine.NumberOfInstances; i++)
{
code.AppendLine($"case {tempInstanceArrayIndex}:");
tempInstanceArrayIndex++;
}
code.AddIndent();
code.AppendLine($"return {efsmDef.StateMachine.IncludeThisStateMachineDefine};");
code.RemoveIndent();
}
}
code.AppendLine("default:");
code.AddIndent();
code.AppendLine("return 0;");
code.RemoveIndent();
code.RemoveIndent();
code.AppendLine("}");
code.RemoveIndent();
code.AppendLine("}");
code.AppendLine();
code.StandardSeparator("Diagnostics");
code.AppendLine("void EFSM_GeneratedDiagnostics(EFSM_INSTANCE * efsmInstance)");
code.AppendLine("{");
code.AddIndent();
code.AppendLine("for(int i = 0; i < efsmInstance->totalNumberOfInputs; i++)");
code.AppendLine("{");
code.AddIndent();
code.AppendLine("efsmInstance->inputBuffer[i] = efsmInstance->InputQueries[i](efsmInstance->indexOnEfsmType);");
code.RemoveIndent();
code.AppendLine("}");
code.RemoveIndent();
code.AppendLine("}");
//code.AppendLine();
//if (project.DiagnosticsEnabled)
//{
// code.AppendLine("/*State Machine State Accessors*/");
// code.AppendLine();
// foreach (var stateMachine in project.StateMachinesGenerationModel)
// {
// if (stateMachine.IncludeInGeneration)
// {
// for (int i = 0; i < stateMachine.NumberOfInstances; i++)
// {
// code.AppendLine($"uint32_t Get_{stateMachine.IndexDefineName.Replace(' ', '_')}_Instance_{i}_State()");
// code.AppendLine("{");
// code.AddIndent();
// code.AppendLine($"return {stateMachine.IndexDefineName.Replace(' ', '_')}_Instance_{i}.state;");
// code.RemoveIndent();
// code.AppendLine("}");
// }
// }
// }
// code.AppendLine();
// code.AppendLine("/*State Machine Input Accessors*/");
// code.AppendLine();
// foreach (var stateMachine in project.StateMachinesGenerationModel)
// {
// if (stateMachine.IncludeInGeneration)
// {
// for (int i = 0; i < stateMachine.NumberOfInstances; i++)
// {
// for (int j = 0; j < stateMachine.Inputs.Length; j++)
// {
// code.AppendLine($"/*Corresponds to input \"{stateMachine.Inputs[j].Name}\" for instance {i} of state machine definition \"{stateMachine.IndexDefineName}\".*/");
// //code.AppendLine($"UINT32 Get_{stateMachine.Name.Replace(' ', '_')}_{i}_Input_{j}()");
// code.AppendLine($"uint32_t Get_{stateMachine.IndexDefineName.Replace(' ', '_')}_{i}_Input_{j}()");
// code.AppendLine("{");
// code.AddIndent();
// code.AppendLine($"return {stateMachine.IndexDefineName.Replace(' ', '_')}_Instance_{i}.inputBuffer[{j}];");
// code.RemoveIndent();
// code.AppendLine("}");
// code.AppendLine();
// }
// }
// }
// }
//}
if ((project.DebugMode == DebugMode.Desktop) && (project.DebuggingEnabled))
{
code.StandardSeparator("EFSM Debugging");
foreach (var stateMachine in binaryGenerationResult.StateMachines)
{
foreach (var input in stateMachine.StateMachine.Inputs)
{
code.AppendLine(input.FunctionSignature);
code.AppendLine("{");
code.AddIndent();
code.AppendLine($"return efsmDebugControl.debugBuffer[EFSM_DEBUG_PROTOCOL_INDEX_CYCLE_CMD_INPUTS_START + {input.FunctionReferenceIndex}];");
code.RemoveIndent();
code.AppendLine("}");
}
code.AppendLine();
foreach (var action in stateMachine.StateMachine.Actions)
{
code.AppendLine(action.FunctionSignature);
code.AppendLine("{");
code.AddIndent();
code.RemoveIndent();
code.AppendLine("}");
}
}
/*Generate the main function.*/
code.AppendLine();
code.AppendLine("int main(int argc, char *argv[])");
code.AppendLine("{");
code.AddIndent();
code.AppendLine("printf(\"Starting the EFSM Debug Manager...\\n\\n\");");
code.AppendLine("strcpy(debugStatusTxFilename, argv[1]);");
code.AppendLine("strcpy(debugCommandRxFilename, argv[2]);\n");
code.AppendLine("while(1)");
code.AppendLine("{");
code.AddIndent();
code.AppendLine("EfsmDebugManager();");
code.RemoveIndent();
code.AppendLine("}");
code.AppendLine();
code.AppendLine("return 0;");
code.RemoveIndent();
code.AppendLine("}");
}
code.AppendLine();
return(code.ToString());
}
public CLIMarshalManagedToNativePrinter(MarshalContext ctx)
: base(ctx)
{
VarPrefix = new TextGenerator();
ArgumentPrefix = new TextGenerator();
Context.MarshalToNative = this;
}
