Sample Win App

iramindustry

Sorry for my limited knowledge with Neoaxis.

The guide for Initial setup "In the project settings set 'Initial UI Screen' to 'Samples\Sample Window App\SampleAppMainForm.ui' ". Is this to be done in Visual Studio? I cannot seem to find it.
Is there a global event where i can put codes for initialization?
If i remembered correctly, Control class has OnAttach(). Is there something that can be used?
How to get this Sample Win App compiled for distribution later? We need to do using Visual Studio?
I guess if we use the Neoaxis.Player.exe, then the codes will be exposed?

betauser

Hi,
Window application creation is a new purpose of the engine. More features will added.

Implied to create all inside the editor, UI and code of event handlers. However, you can use Visual Studio too for writing code. Main idea is making everything in the editor.

Set 'Initial UI Screen' in the editor. Now player will started with your UI file. This is main form of the application. Also in project settings you can configure window size, state.

You can change NeoAxis Player code. As example rename it to your project name. By idea that is all, your application is ready to use. Also you can build product to make package smaller.

Please ask. We will write tutorials later little bit later.

iramindustry

I want to handle the different events in the SampleAppMainForm.cs.

OnAttach: need an event that is called once, to use OnLoad?
OnTick: should this be mapped to OnUpdate?
OnRender: this can map to OnRenderUI

For example, it will look like this:
protected override void OnRenderUI( CanvasRenderer renderer ) {
base.OnRenderUI(renderer);
Log.Info("OnRenderUI ----");
}

betauser

Best method for component initialization:
protected override void OnEnabledInSimulation()
{
base.OnEnabledInSimulation();

}

For update you can use OnUpdate and OnSimulationStep.
Update - call before frame rendering, SimulationStep - call each world tick.

In RenderUI you can draw additional GUI.
renderer.AddQuad(...)

iramindustry

Thanks for highlighting those default functions to be used.

What i am trying to migrate over is an engine to write "low level" codes, mainly for 2D games.
These codes can be now in a .CS file as below since the editor can support it now.

using Engine; namespace LowLevelEngine { public class LineTest { public void OnInit() { //initialisation codes here } public void OnTick(float delta) { //codes for logics } public void OnRender(GuiRenderer renderer) { //rendering codes } } }

The question is how to load this .CS file since the Assembly class is not available.
The editor needs a .UI file to be able to trigger the Player. How to go pass this?

Regards.

betauser

Hi, any progress? Not sure what means Assembly class is not available.
Need open additional .ui file from event handler of Sensor?
More about event handlers: https://www.neoaxis.com/docs/html/Event_Handlers.htm
Or just click button by user. In this case event handlers can be used too)

iramindustry

I want some scripts to be able to take over and draw to the screens. They can be loading textures and then render sprites.

This means when the App is started, it will show the output directly. No need to click on button from UI.

For example, something like this when they do the calculation onUpdate() and then draw onRender().

iramindustry

For the question on Assembly, this is what i have previously.

` private Assembly BuildAssembly (string code) {

        System.CodeDom.Compiler.CodeDomProvider provider = new CSharpCodeProvider();
        CompilerParameters compilerparams = new CompilerParameters();
        compilerparams.GenerateExecutable = false;
        compilerparams.GenerateInMemory = true;
        compilerparams.ReferencedAssemblies.Add("System.dll");
        
        foreach (string extraDll in lowLevelLibrary)
        {
            compilerparams.ReferencedAssemblies.Add(extraDll);
        }
        CompilerResults results = provider.CompileAssemblyFromSource(compilerparams, code);

        if (!results.Errors.HasErrors)
        {
            return results.CompiledAssembly;
        }
        else
        {
            StringBuilder errors = new StringBuilder("Compiler Errors :\r\n");
            foreach (CompilerError error in results.Errors)
            {
                errors.AppendFormat("Line {0},{1}\t: {2}\n", error.Line, error.Column, error.ErrorText);
            }
            //throw new Exception(errors.ToString());
            Log.Fatal(scriptLogSignature + " :: BuildAssembly :: " + errors.ToString());
            return null;
        }
    }

    public object ExecuteCode(string code, string namespacename, string classname, string functionname, bool isstatic, params object[] args)
    {
        object instance = null;
        Type type = null;

        object returnval = null;

        Assembly asm = BuildAssembly(code);
        if (isstatic)
        {
            type = asm.GetType(namespacename + "." + classname);
        }
        else
        {
            instance = asm.CreateInstance(namespacename + "." + classname);
            type = instance.GetType();
        }

        MethodInfo method = type.GetMethod(functionname);
        returnval = method.Invoke(instance, args);

        return returnval;
    }`

betauser

Ok) You need 2D canvas and activate it when player starts.

Make .ui file with Control class. Set "Create C# class" check box in creation form.
(Restart editor)
Set control size "Screen 1 1". Now it fullscreen.
Set this file in the project settings to 'Initial UI Screen' parameter.
Now your canvas is configured.
You can add more controls in the UI editor as children.
To render on canvas make override OnRenderUI method in your C# class of the control.

You can make OnRenderUI in the editor or in the Visual Studio. You can find your .cs in the Project project.

betauser

Drawing a quad:
renderer.AddQuad( new Rectangle( 0.1, 0.1, 0.9, 0.9 ), new ColorValue( 1, 0, 0 ) );

betauser

You also can try draw in the main menu. Base\UI\Screens\MainMenuScreen.cs.

protected override void OnRenderUI( CanvasRenderer renderer )
{
base.OnRenderUI( renderer );

renderer.AddQuad( new Rectangle( 0.1, 0.1, 0.9, 0.9 ), new ColorValue( 1, 0, 0 ) );

}

iramindustry

Yes, i can render the red box on top of the empty UI class.

Where is the place to take a look on how to build the .CS file and able to execute it?

betauser

iramindustry

Yes, i created the control class.

The reason why i need to compile external files containing scripts is because i wanted one control class to handle multiple scripts.

It is similar to that UI that shows the list of scenes and allow to select one. I need to pass in the name of the script file and it will render that. If i passed another file, then it will render the new one.

As indicated earlier, each script file will be like this:

Script File A

iramindustry

I checked the sources and found that there are codes that i am looking for, but they are not public:

ScriptCompiler
ScriptingCSharpEngine

After creating the assembly from either of these classes, need to be able to invoke the functions in the scripts.

betauser

By idea you can have one canvas with additional controls on top. Each additional control can have own .cs file or built-in C# script.

As example:

MyScript1.ui, MyScript1.cs
MyScript2.ui, MyScript2.cs

Or you can add just component without UI. But I as understand, you want switch several UI.

If it good, then need know how to add additional control to the canvas.
Check ChangeUIScreen method in the SimulationApp.cs. Your code will like this.
var uiComponent = ResourceManager.LoadSeparateInstance<UIControl>( virtualFileName, false, true ); MainViewport.UIContainer.AddComponent( uiComponent );

uiComponent.Dispose() to remove.

iramindustry

How to get the value of the Editor Settings like the Name, Text, or Enabled?

iramindustry

Just to give an update of my progress of the LowLevelEngine that i have migrated.
Note that it requires System.CodeDom.dll, which i noticed is not included in the 2020.5, please help to include it.

Basically the LowLevelEngine also scripts to be created, and it can use the NeoAxis Editor for development.
In the screenshot, you can see the cs file that can be edited directly.

While the Player is running, you can press F5 to see the latest changes without restarting. This is to reduce the time taken to start the Player.

betauser

iramindustry Note that it requires System.CodeDom.dll, which i noticed is not included in the 2020.5, please help to include it.

You can add reference to dll. It already in the Binaries folder.

betauser

Looks great, thanks for sharing!

Here is close to implement hot update without restarting. Please tell about your experience, how you made it? I think we can wait with 2020.5 release and implement the feature before release.

Also I have idea to remove NeoAxis.CoreExtension.dll assembly. One part of sources move to NeoAxis.Core.dll, another to Project.dll. In result we will have one engine dll and one project dll.

iramindustry

Basically I used the SampleWinApp as a starting ground to implement the LowLevelEngine.

Ideally i will want to be able to pass the name of the CS to the LowLevelEngine so that it will run that directly.
Currently it is still coded in the source:

If you looked at the previous screen, i have only 1 LowLevelEngine.cs and 1 LowLevelEngine.ui.
I have as many CS files since they are supposed to be the mini codes that can be executed, all of them are for 2D rendering at this point.

I have to change EngineConsole a bit so that it is full height and also a simple rotating cursor.
static string cursor = "|/-\";

The aim is to be able to build the mini codes as fast as possible.
This means once the Player is started, i will just keep amending the codes (of course, runtime errors or compilation will need a restart) and see the output directly. Maybe it is like a scene except this is all done in codes.

If you find this is useful, i can provide you the LowLevelEngine.cs so that you can integrate into NeoAxis.
The codes can be a bit messy now since i am doing it outside my day job. 😆