C# wrapper - RELEASE

a7.EngFun.level_load( (String)"..\\gsDefaults\\default.wmb" );

a7.EngFun.level_load( (String)"default.wmb" );

"C:\Program Files\GStudio7\WED.exe" -p "$(TargetDir)\$(TargetFileName)"

while (a7.EngFun.engine_frame() != 0) 
{ 
	UpdateAcknex(); // update your acknex stuff here
	Application.DoEvents(); //Add this here 
}

//get the x/y pos 
int left = System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Left;
int top = System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Top + 
                                                       Program.gamePlayForm.Height;
//get the w/h
int right = System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Right;
int bottom = System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Bottom - top;

//place the position (left,top)/ (right/bottom) in vectors 
a7.Vector vWinPos = new a7.Vector((a7.Var)left, (a7.Var)top, (a7.Var)0);
a7.Vector vWinSize = new a7.Vector((a7.Var)right, (a7.Var)bottom, (a7.Var)0);

//set title
String winTitle = "Engine: ";


//place the window at position (left,top)
a7.EngFun.video_window(vWinPos, vWinSize, (a7.Var)2, winTitle);

//QUIT
private void quitToolStripMenuItem_Click1(object sender, EventArgs e)
{
    //close engine
    if(a7.EngFun.engine_frame() != 0)
         a7.EngFun.engine_close();
    //and exit
    Application.Exit();
}

while(1)
{
      ... other stuff

   /// this is equivalent to wait(1)
   a7.EngFun.engine_frame(); break;
}

[DllImport("user32.dll", EntryPoint = "GetWindowText", CharSet = CharSet.Ansi)]
        public static extern bool GetWindowText(IntPtr hWnd, [OutAttribute()] StringBuilder strNewWindowName,
            Int32 maxCharCount);

        static void Main(string[] args)
        {
            a7.EngFun.engine_open(null);
            a7.EngFun.engine_frame(); // acts as wait(1) ???

            StringBuilder sb = new StringBuilder(256);
            GetWindowText(a7.EngVar.hWnd, sb, sb.Capacity);
            MessageBox.Show(sb.ToString());

            while (a7.EngFun.engine_frame() != 0)
            {

            }
        }
    }

using System.Runtime.InteropServices;

const int WS_VISIBLE = 0x10000000;
const UInt32 SWP_SHOWWINDOW = 0x0040;

[DllImport("user32.dll")]
static extern IntPtr SetParent(IntPtr hWndChild, IntPtr hWndNewParent);

[DllImport("user32.dll")]
static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

[DllImport("user32.dll")]
static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

a7.EngFun.engine_open(null);
a7.EngFun.engine_frame(); // Required else crash (D3D isnt loaded yet)

SetParent(a7.EngVar.hWnd, MyPanel.Handle);
SetWindowLong(a7.EngVar.hWnd, -16, WS_VISIBLE);
SetWindowPos(a7.EngVar.hWnd, (IntPtr)0, 0, 0, MyPanel.Width, MyPanel.Height,
SWP_SHOWWINDOW);

while (a7.EngFun.engine_frame() != 0)
{

}

EngVar.time_smooth.FloatValue = 0.666f;

            //CRASHES:: ?????
            //collision
            //EngVar.enable_polycollision.IntValue = (int)1;

            EngVar.floor_range.IntValue = (int)100;

public void SetVar(ref Var sender, object value)
        {
            if(value.GetType() == typeof(int))
            {
                sender.IntValue = (int)value;
            }
            if (value.GetType() == typeof(float))
            {
                sender.FloatValue = (float)value;
            }
        }

//
        public static String levels = Application.StartupPath + @"\gsDefaults\levels\";
        public static String models = Application.StartupPath + @"\gsDefaults\models\";
        public static String terrains = Application.StartupPath + @"\gsDefaults\terrains\";
        public static String props = Application.StartupPath + @"\gsDefaults\props\";
        public static String textures = Application.StartupPath + @"\gsDefaults\textures\";
        public static String fx = Application.StartupPath + @"\gsDefaults\fx\";
        public static String ppfx = Application.StartupPath + @"\gsDefaults\pp_fx\";

public static String strDefLevel = levels + "default.wmb";
        public static String strDefEntity = models + "camnode.mdl";

OR

Actor = EngFun.ent_create(models + "cbabe.mdl", new Vector(0, 0, 32), ActorAction);

ENTITY* skycube =
{
  type = "t_day_sky+6.tga"; // the image for a backdrop scene
  flags2 = SKY | CUBE | SHOW; // sky cube, visible
}

aFXCamera.stage = (IntPtr)null;

aFXCamera.stage = (VIEW)(IntPtr)null;

/* -------- VIEW -------- */
        /* VIEW to NativeVIEW* (address in void*) */
        public static explicit operator IntPtr(VIEW d)
        {
            unsafe
            {
                return (IntPtr)(NativeVIEW*)d.VIEWPointer; // CRASH HERE!
            }
        }

class Engine:
	
	ev as ENGINE_VARS
	
	def constructor(commandline as string):
		ev = Marshal.PtrToStructure(engine_open(commandline), ENGINE_VARS)
	def frame():
		return engine_frame()
	def close():
		engine_close()
		
	version as single:
		get: return _FLOAT(Marshal.ReadInt32(ev.version))
	edition as int:
		get: return _INT(Marshal.ReadInt32(ev.edition))
	compatibility as int:
		get: return _INT(Marshal.ReadInt32(ev.compatibility))
		set: Marshal.WriteInt32(ev.compatibility, _VAR(value))
	
	...

using System;
using a7;

namespace test
{
	class Program
	{
		public static void Main(string[] args)
		{
			Engine e = new Engine("-nwnd");
			Console.WriteLine(e.version);
			Vector v1 = new Vector(10, 10, 10);
			Vector v2 = new Vector(30, 30, 30);
			Vector v = v1 + v2;
			Console.WriteLine(v);
			while(e.frame() != 0)
			{
				
			}
			e.close();
		}
	}
}

public class Actor : ENTITY
{
        /*create entity player*/
        private static ENTITY m_actor = null; 
        ...
        public Actor()
        {
           // m_actor = new ENTITY();  //CRASH
           // m_actor = (ENTITY)EngVar.player; //CRASH
           //m_actor = (ENTITY)EngFun.ent_create(null, new Vector(0, 0, 0), null); //CRASH
           ...
        }
        ...
}

public class Var
    {
        private NativeVar HiddenVar = new NativeVar();
        private IntPtr VarIntPtr = IntPtr.Zero;

        private int mValue
        {
            get
            {
                if (VarIntPtr != IntPtr.Zero)
                {
                    unsafe
                    {
                        HiddenVar = *((NativeVar*)VarIntPtr);
                    }
                }
                return HiddenVar.mValue;
            }
            set
            {
                HiddenVar.mValue = value;
                if (VarIntPtr != IntPtr.Zero)  //update structure in unmanaged memory if the var was already used as IntPtr
                {
                    Marshal.StructureToPtr(HiddenVar, VarIntPtr, false); //CRASH HERE
                }
            }
        }

public class Actor : ENTITY
    {
        private static ENTITY m_actor = null;

        public Actor()
        {
            m_actor = new ENTITY();  //CRASH
            m_actor = (ENTITY)EngVar.player; //CRASH
            m_actor = (ENTITY)EngFun.ent_create(null, new Vector(0, 0, 0), null); //CRASH
        }
    }

Actor testactor = new Actor();

Actor m_actor = new Actor(models + "cbabe.mdl", new Vector(0, 0, 16), Actor.ActorAction);

EngFun.vec_set(EngVar.target,player.xyz);
EngFun.vec_sub(EngVar.target,EngVar.camera.xyz);
EngFun.vec_to_angle(EngVar.camera.panTiltRoll,EngVar.target);

int x = EngFun.clamp((Var)3, (Var)4, (Var)5).IntValue;

int x = EngFun.clamp(3, 4, 5);

Var TempVar = new Var(3);
TempVar = 4;

ENTITY Dummy = EngFun.ent_create("dummy.mdl", new Vector(0, 0, 0), null);
MySky.z.IntValue += 30;

Var xxx = null;
int z = xxx;

z = 0

BMAP* arrow = "arrow.pcx";
mouse_map = arrow;
mouse_mode = 2;
int snap_amount = 30;
double ux = 0.0;
double uy = 0.0;

while (1) // move it over the screen
{  
ux = mouse_cursor.x / snap_amount;
uy = mouse_cursor.y / snap_amount;
		
mouse_pos.x = (integer(ux)*snap_amount);
mouse_pos.y = (integer(uy)*snap_amount);
wait(1);
}

BMAP* arrow = EngFun.bmap_create("arrow.pcx");
EngVar.mouse_map = arrow;
EngVar.mouse_mode.IntValue = 2;
int snap_amount = 30;
double ux = 0.0;
double uy = 0.0;

while(true)
{
ux = (EngVar.mouse_cursor.x.FloatValue / snap_amount);
uy = (EngVar.mouse_cursor.y.FloatValue / snap_amount);

EngVar.mouse_pos.x.IntValue = (EngFun.integer((Var)ux).IntValue * snap_amount);
EngVar.mouse_pos.y.IntValue = (EngFun.integer((Var)uy).IntValue * snap_amount);
yeild return 1;
}

BMAP arrow = EngFun.bmap_create("arrow.pcx");
EngVar.mouse_map = arrow;
EngVar.mouse_mode.IntValue = 2;
int snap_amount = 30;
double ux = 0.0;
double uy = 0.0;

while(true)
{
ux = (EngVar.mouse_cursor.x.FloatValue / snap_amount);
uy = (EngVar.mouse_cursor.y.FloatValue / snap_amount);

EngVar.mouse_pos.x.IntValue = (EngFun.integer((Var)ux).IntValue * snap_amount);
EngVar.mouse_pos.y.IntValue = (EngFun.integer((Var)uy).IntValue * snap_amount);
yield return 1;
}

public IEnumerable DragPanel()
{
PANEL sender = EngVar.mouse_panel;
int startx = EngVar.mouse_cursor.x.IntValue - sender.pos_x.IntValue;
int starty = EngVar.mouse_cursor.y.IntValue - sender.pos_y.IntValue;

while (EngVar.mouse_left.IntValue == 1)
{
if (EngVar.mouse_moving.IntValue == 1)
{
sender.pos_x.IntValue = EngVar.mouse_cursor.x.IntValue- startx;
sender.pos_y.IntValue = EngVar.mouse_cursor.y.IntValue -starty;
}
yield return 1;
}
}

PANEL pnl = EngFun.pan_create("bmap = hi.bmp;",(Var)1);
pnl.pos_x.IntValue = 0;
pnl.pos_y.IntValue = 0;
pnl.event_ = DragPanel;
pnl.SHOW = true;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using AcknexWrapper;
using System.Collections;

namespace game
{
    class Program
    {
        static IEnumerable mouse()
        {
            BMAP arrow = EngFun.bmap_create("mouse.bmp");
            EngVar.mouse_map = arrow;
            EngVar.mouse_mode.IntValue = 2;

            while (true)
            {
                EngVar.mouse_pos.x.FloatValue = EngVar.mouse_cursor.x.FloatValue;
                EngVar.mouse_pos.y.FloatValue = EngVar.mouse_cursor.y.FloatValue;
                yield return 1;
            }
        }

        public static IEnumerable DragPanel()
        {
            Console.WriteLine("i was called !");

            PANEL sender = EngVar.mouse_panel;
            int startx = EngVar.mouse_cursor.x.IntValue - sender.pos_x.IntValue;
            int starty = EngVar.mouse_cursor.y.IntValue - sender.pos_y.IntValue;

            while (EngVar.mouse_left.IntValue == 1)
            {
                if (EngVar.mouse_moving.IntValue == 1)
                {
                    sender.pos_x.IntValue = EngVar.mouse_cursor.x.IntValue - startx;
                    sender.pos_y.IntValue = EngVar.mouse_cursor.y.IntValue - starty;
                }
                yield return 1;
            }
        }

        static IEnumerable MainMethod()
        {
            PANEL pnl = EngFun.pan_create("bmap = mouse.bmp;", (Var)1);
            pnl.pos_x.IntValue = 0;
            pnl.pos_y.IntValue = 0;
            pnl.event_ = DragPanel;
            pnl.SHOW = true;
            yield return 1;
        }

        static void Main(string[] args)
        {
            EngFun.engine_open(null);
            Scheduler.AddEventVoid(mouse);
            Scheduler.StartScheduler(MainMethod);
        }
    }
}

EngVar.mouse_pos.x.IntValue = EngVar.mouse_cursor.x.IntValue;
EngVar.mouse_pos.y.IntValue = EngVar.mouse_cursor.y.IntValue;

viewTo.flags = ((int)(viewTo.flags & ~Flags.NOSHADER) | (m_camera.flags & Flags.NOSHADER));

yield return -1; //pause the method for 1 second
yield return 1; //pause the method for 1 frame

private Var dy_ = null;
        public Var dy
        {
            get
            {
                unsafe
                {
                    if (dy_ == null)
                    {
                        dy_ = (Var)(IntPtr)(&((*FONTPointer).dy));
                    }
                }
                return dy_;
            }
        }

/// <summary>
        /// dy - see Gamestudio manual
        /// </summary>
        public int dy
        {
            get
            {
                unsafe
                {
                    return (*FONTPointer).dy;
                }
            }
        }

MATERIAL mat_ent = EngFun.mtl_create();
ENTITY entity = EngFun.ent_create("blob.mdl", new Vector(150, 0, 0), null);
mat_ent.skin1 = EngFun.bmap_create("t_day_sky+6.tga");
entity.material = mat_ent;
entity.SHOW = true;

EngFun.bmap_to_cubemap(mat_ent.skin1);
EngFun.effect_load(mat_ent, "envglass.fx");

override public unsafe void createComponent(int *posX, int *posY)
{
  BMAP myMap = EngFun.bmap_create("component.tga");

  myPan = EngFun.pan_create(null, 1);
  myPan.bmap = myMap;
  myPan.flags |= Flags.VISIBLE;
            
  myPan.pos_x.IntValue = *posX;
  myPan.pos_y.IntValue = *posY;
}

ENTITY my = ent_create("guard.mdl",new Vector(0,0,50),null);
my.animate("stand", my.skill1, (Var)(int)EngFun.ent_anim_FLAGS.ANM_CYCLE);

ENTITY my = ent_create("guard.mdl",new Vector(0,0,50),null);
my.animate("stand", my.skill1, EngFun.ent_anim_FLAGS.ANM_CYCLE);

TEXT my_text = EngFun.txt_create(1, 0);
my_text.pos_x.IntValue = 100;
my_text.pos_x.IntValue = 100;
EngFun.str_cpy(my_text.pstring[0], "Hello World");
my_text.flags = Flags.INVISIBLE | Flags.SHOW;

EngFun.txt_addstring(my_text, "test");

TEXT my_text = EngFun.txt_create(2, 0);
my_text.pos_x.IntValue = 100;
my_text.pos_x.IntValue = 100;
Var v = EngFun.txt_addstring(my_text, "test");
STRING s = EngFun.txt_str(my_text, v.IntValue);
my_text.flags = Flags.INVISIBLE | Flags.SHOW;

TEXT my_text = EngFun.txt_create(2, 0);
            my_text.pos_x.IntValue = 100;
            my_text.pos_x.IntValue = 100;
            my_text.pstring = new String[] { "asdfasdf", "asdfasfd" };
            my_text.flags = Flags.SHOW;
            yield return 200;
            my_text.pstring = new String[] { "234234", "234324" };

var a = 45;
var b = 7.86;
var c = "hello world";
var d = false;

public void ChangeMe(ref int i)
{
i++;
}
...
int x = 3;
ChangeMe(ref x);
// now x = 4

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace lambdaTest
{
    class Program
    {
        delegate int getValueOfReference();

        static getValueOfReference newReferenceStorage = null;

        static void dummy(int valueInteger)
        {
            newReferenceStorage = () => { return valueInteger; };

            //that's how it should look like - but unfortunately doesn't work in c#
            //newReferenceStorage = () => { return refInteger; };
        }

        static void Main(string[] args)
        {
            int refInteger = 3;
            int valueInteger = 4;

            dummy(ref refInteger, valueInteger);

            valueInteger++;

            //when newReferenceStorage is called, the anonymous method is called..
            Console.WriteLine("variable : " + valueInteger);
            Console.WriteLine("lambda expresssion : " + newReferenceStorage());

            //give some time to read the output...
            Console.ReadLine();
        }
    }
}

int dummyVariable = 3;



EngFun.pan_setvar(
  dummyPanel,
  1,
  1,
  delegate() { Reference.acquire(ref dummyVariable); }
);

//or (the same)

EngFun.pan_setvar(
  dummyPanel,
  1,
  1,
  () => { Reference.acquire(ref dummyVariable); }
);

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class ReferenceStorage
    {
        public delegate double getValue();
        public delegate void setValue(double value);
        public getValue getValueLambda;
        public setValue setValueLambda;

        public ReferenceStorage(getValue getValueLambda, setValue setValueLambda)
        {
            this.getValueLambda = getValueLambda;
            this.setValueLambda = setValueLambda;
        }


    }

    class Program
    {
        /* this method should depict the engine, changing/reading through the reference */
        static void backgroundFunction(ReferenceStorage.getValue getValue, ReferenceStorage.setValue setValue)
        {
            /* 
             * if a permanent reference to that variable would be needed,
             * create a Reference Storage, to keep the two Lambda expressions
             * 
             * code :
             * 
             * ReferenceStorage newStorage = new ReferenceStorage(getValue, setValue);
             */


            while (true)
            {
                setValue(getValue() + 1);
                Console.WriteLine(getValue() + " increased, using lambda expression");

                System.Threading.Thread.Sleep(1500);
            }

        }

        /* a method that would be called from the user */
        static void dummyWrapperFunction(ReferenceStorage.getValue getValue, ReferenceStorage.setValue setValue)
        {
            System.Threading.Thread t = new System.Threading.Thread(
                () => { backgroundFunction(getValue, setValue); }
            );
            t.Start();
        }



        static void Main(string[] args)
        {
            double dummyValue = 30;

            /* call a dummy wrapper function and pass a 'reference' to the value type dummyValue 
             *
             * THIS is the code that user would have to enter, if the panel function would read AND write into the variable
             */
            dummyWrapperFunction(
                () => { return dummyValue; },
                (double newDummyValue) => { dummyValue = newDummyValue; }
            );

            while (true)
            {
                dummyValue += 1;
                Console.WriteLine(dummyValue + " increaesd, through directly increasing the variable");

                System.Threading.Thread.Sleep(1500);
            }
        }
    }
}

float bla = 30.2;

float bla = 30.2f;

void dummy(ref int x) 
{
only here x is valid !, as soon as the program jumps back to where dummy was called 
from, x is invalid ! 

this works fine as long as we don't want to pass a permanent reference to a variable!
to make it permanent it would be necessary to stay as long in this scope, as we need the ref !
I tried that with Threads, but as mentioned - too much overhead and calling the function is 
at least as ugly as the lambda approach ...
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace dummyTest
{
    class Program
    {
        static void changeVariableValue(object i)
        {
            int bla = (int)i;   //unbox
            bla++;
        }

        static void Main(string[] args)
        {
            int bla = 30;
            changeVariableValue(bla);
            Console.WriteLine(bla);

            Console.ReadLine();
        }
    }
}

using System;

namespace AnonymousMethod
{
	delegate int Func();
	
	class Program
	{
		static Func[] funcArr = new Func[10];

		static void setPanelVariable(int i, Func f)
		{
			funcArr[i] = f;
		}

		static void Main(string[] args)
		{
			int i1 = 10;
			int i2 = 20;
			int i3 = 30;
			
			setPanelVariable(0, () => i1);
			setPanelVariable(1, () => i2);
			setPanelVariable(2, () => i3);
			
			for (int i = 0; i < 3; i++)
			{
				Console.WriteLine(funcArr[i]());
			}

			i1 = 111;
			i2 = 121;
			i3 = 131;
			
			for (int i = 0; i < 3; i++)
			{
				Console.WriteLine(funcArr[i]());
			}
			
			Console.ReadLine();
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Collections;

using AcknexWrapper;

using System.Threading;

namespace OldWrapperTestApp
{
    class Program
    {
        private static DateTime StartTime = DateTime.Now;

        static IEnumerable bla()
        {
            yield return 1;
        }

        static void dummyFun()
        {
            Thread.Sleep(1000);
            while (true)
            {
                Console.WriteLine(DateTime.Now - StartTime);
                Scheduler.AddEventVoidThreadSafe(bla);
                //Scheduler.AddEventVoid(bla);
                Thread.Sleep(2);
            }
        }

        static void Main(string[] args)
        {
            EngFun.engine_open(null);
            EngFun.level_load(null);

            Thread t = new Thread(dummyFun);
            t.Start();

            Scheduler.StartScheduler(bla);

        }
    }
}

AddEventVoid

1.)  00:00:16.4375000 - crash
2.)  00:00:40.8750000 - crash
3.)  00:00:04.4375000 - crash
4.)  00:00:04.2968750 - crash
5.)  00:06:12.2968750 - crash
6.)  00:00:03.3750000 - crash
7.)  00:00:45.0781250 - crash
8.)  00:00:05.2968750 - crash
9.)  00:00:07.7031250 - crash
10.) 00:00:14.4687500 - crash

AddEventVoidThreadSafe

1.) ~ 00:02:30 - aborted by user - no crash
2.) ~ 00:02:45 - aborted by user - no crash
3.) ~ 00:02:30 - aborted by user - no crash
4.) ~ 00:03:00 - aborted by user - no crash
5.) ~ 00:02:30 - aborted by user - no crash

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using AcknexWrapper;

namespace AcknexTest
{
    class Program
    {
        static void Main(string[] args)
        {
            EngFun.engine_open(null);
            EngFun.error("Hello World!");
            Scheduler.StartScheduler(null);
        }
    }
}

/// <summary>
        /// engine_frame - see Gamestudio manual
        ///  - for more detailed and up to date documentation, visit http://manual.3dgamestudio.net/ </summary>
        public static int engine_frame()
        {
            return NativeEngFun.engine_frame();
        }

private void button3_Click(object sender, EventArgs e)
        {
            OpenFileDialog LoadModel = new OpenFileDialog();
            LoadModel.Title = "Import Model";
            LoadModel.InitialDirectory = @"C:\";
            LoadModel.Filter = "MDL (*.mdl)|*.mdl|Alle Dateien (*.*)|*.*";
            LoadModel.FilterIndex = 1;
            LoadModel.RestoreDirectory = true;
            if(LoadModel.ShowDialog() == DialogResult.OK)
            {
                ENTITY.ent_create(LoadModel.FileName, new Vector(100, 100, 0), obj);
                _items.Add(LoadModel.FileName);
                listBox1.DataSource = null;
                listBox1.DataSource = _items;
            }
        }

private void button_LoadLevel_Click(object sender, EventArgs e)
        {
            //you can still put opendialog here
            //i use a global "levelloaded" string in a static
            //class called Global accessed through properties.
            ...
            Global.strLoadedLevel = opendialog.filename;

            Scheduler.AddEventVoidThreadSafe(LoadLevel);
        }
     
private IEnumerable<ScheduleMethod> LoadLevel()
        {
            //i use a Global.strLoadedLevel as string
            if(Global.strLoadedLevel != string.empty}
             {
                EngFun.level_load(Global.strLoadedLevel);

		//reinit camera
                InitCamera();
             }
            yield break;
        }

public static class Global
        {
            public static string entity_import;
        }

public static class Global
        {
            private static string entity_import;

            public static string Import
            {
               get {return entity_import;}
            }
        }

public Vector xyz
{
	get
	{
		return Vector.createFromPointer(xPointer);
	}
	set
	{
		Vector.createFromPointer(xPointer).vec_set(value);
	}
}

skyStars.xyz = camera.xyz;

skyStars.xyz.vec_set(camera.xyz);

public static double clamp(double x, double a, double b)
{
	if (x < a) return a;
	if (x > b) return b;
	return x;
}

public int Width
{
	get
	{
		return bmap_width();
	}
}