Sorry your browser is not supported!

load object 1, "bleh.x"

myObject = LoadObject("bleh.x")

// main loop
do

   // update all players
   for i = 0 to players : updatePlayer(i) : next i

   // update all particles
   for i = 0 to particles : updateParticles(i) : next i

   // etc..

loop

do
    update(root)   // updates EVERYTHING
loop


// where update() is defined as something like:
function update(ent as Entity)
    for i = 0 to ent.childCount
        update(ent.child[i])  // or w/e array access syntax you want
    next i
endfunction


function update(ent as Object)
    // do specific updates for objects
endfunction


function update(ent as Light)
    // do specific updates for lights
endfunction

etc...

CreateSprite(player, playerTexture)

player = CreateSprite(playerTexture)

player as integer
player = CreateSprite(PlayerTexture)
PositionSprite(player, 10, 10)

player as sprite
player = CreateSprite(PlayerTexture)
PositionSprite(player, 10, 10)

player as object
cam as camera
SetPosition(player, 10, 10, 10)
SetPosition(cam, 100, 100, 100)

player as object
player.SetPosition(10, 10)

player as sprite
player = CreateSprite()
player.image = LoadImage("x.bmp")

class SomeResource
{
public:
	SomeResource( args )
		: exists_( true )
		, refCount_( 1 )
		, someData_( new char[1024*1024] )
	{
	}
	~SomeResource()
	{
		assert( exists_ );
	}
	
	void deleteData()
	{
		exists_ = false;
		delete [] someData_;
		someData_ = nullptr;
	}
	bool exists() const
	{
		return exists_;
	}
	
	void incRefCount(){ ++refCount_; }
	void decRefCount(){ if ( (--refCount_) == 0 ) delete this; }
	
private:
	bool exists_;
	int refCount_;
	char* someData_;
};

SomeResource* LoadSomeResource( args )
{
	return new SomeResource( args );
}
void DeleteSomeResource( SomeResource* resource )
{
	assert( resource );
	assert( resource->exists() );
	resource->deleteData();
}
void SetResourcePosition( SomeResource* resource, const Vector& newPosition )
{
	assert( resource );
	assert( resource->exists() );
	resource->setPosition( newPosition ); // Isn't defined
}
bool ResourceExists( const SomeResource* resource )
{
	return resource && resource->exists();
}

player as SomeResource
player = LoadSomeResource( blah ) // I presume there's no point in allowing creation of resources without assigning them, so this wouldn't have to inc the ref count

enemy.target = player // This assignment does: if ( player ) player->incRefCount()   -- refCount_ == 2

player = 0 // This assignment does: if ( player ) player->decRefCount()   -- refCount_ == 1

Print( ResourceExists( enemy.target ) ) // Prints true
if enemy.target // Calls ResourceExists
	SetResourcePosition( enemy.target, blah )
endif

DeleteSomeResource( enemy.target ) // Remove the resource data(the bit that uses up 99~% of the memory)

Print( ResourceExists( enemy.target ) ) // Prints false, but most importantly, it will never become valid again until it's reassigned
if enemy.target // Calls ResourceExists
	SetResourcePosition( enemy.target, blah )
endif

enemy.target = 0 // This assignment does: if ( enemy.target ) enemy.target->decRefCount()   -- refCount_ == 0, finally remove the resource container

type myType
   dim myarr[] as integer  // just assume any syntax you want for a dynamic array in a type
endtype

...


function myfunc()
   test as myType
   Add(test.myarr, 1)   // just add some values for fun
   Add(test.myarr, 2)

   // test goes out of scope here. It's memory is reclaimed, but since it only contains a pointer to an array, rather than containing the array itself, what happens with the array?
endfunction

type myType
    myArr as array of myType
endtype

type mytype
   circular as mytype2
endtype

type mytype2
   circular as mytype
endtype

mytype temp1
mytype2 temp2

temp1.circular = temp2
temp2.circular = temp1


// now you have: temp1.circular.circular.circular.circular == temp1

struct Entity
{
	std::Vector<int> someArray;
};

int main()
{
	Entity derp;
	derp.someArray.push_back( 1337 )
} // Goes out of scope and deallocates itself, no memory leak

sprite = CreateSprite()
texture = LoadTexture("x.bmp")
TextureSprite(sprite, texture)
DeleteTexture(texture)

class Object
{
public:
   std::vector<Object *> objects;  // these are other objects in the UDT
   bool marked;

   Object() : marked(false)
   {
   }

   void mark()
   {
      if (!marked)
      {
         marked = true;

         for (size_t i = 0; i < objects.size(); i++)
            objects[i]->mark();
      }
   }

};


// do garbage collection
void gc(std::vector<Object *> &objects)   // generally need to pass in all active objects, but again, this can be optimised
{
   for (size_t i = 0; i < objects.size(); i++)
      objects[i]->mark();

   for (size_t i = 0; i < objects.size(); i++)
      if (!objects[i]->marked)
      {
         delete objects[i];
         objects.erase(objects.begin() + i);
      } 
}

#include <iostream>      // For debug output
#include <stdlib.h>
#include <set>

class Resource
{
public:
	Resource()
		: dataExists_( true )
		, refCount_( 1 )
	{
#ifdef DEBUG
		std::cout << "Created resource\n";
#endif
	}

	~Resource()
	{
		if ( dataExists_ )
			throw "Data must be deleted via global function";
	}
	
	void deleteData()
	{
		if ( dataExists_ == false )
			throw "Data has already been deleted";
		
		dataExists_ = false;
		decRefCount();
		
#ifdef DEBUG
		std::cout << "Destroyed resource\n";
#endif
	}
	bool dataExists() const{ return dataExists_; }
	void incRefCount(){ ++refCount_; }
	void decRefCount(){ if ( (--refCount_) == 0 ) delete this; }
	
private:
	bool dataExists_;
	int  refCount_;
};

// Calls inc/dec RefCount
class StrongHandle
{
public:
	StrongHandle() : res_(0){}
	StrongHandle( const StrongHandle& o ) : res_( o.res_ )
	{
		if ( res_ )
			res_->incRefCount();
	}
	StrongHandle( Resource* res ) : res_( res )
	{
		if ( res_ )
			res_->incRefCount();
	}
	~StrongHandle()
	{
		if ( res_ )
			res_->decRefCount();
	}
	
	StrongHandle& operator = ( const StrongHandle& o )
	{
		if ( o.res_ )
			o.res_->incRefCount();
		if ( res_ )
			res_->decRefCount();
		
		res_ = o.res_;
		
		return *this;
	}
	
private:
	Resource* res_;
	
	friend class WeakHandle;
};

// Basically wraps the passing of the Resource ptr
class WeakHandle
{
public:
	WeakHandle( const StrongHandle& sh ) : res_( sh.res_ )
	{
		if ( !res_ )
			throw "Invalid resource";
	}
	
	Resource* operator -> () const
	{
		return res_;
	}
	
	Resource* getResource() const{ return res_; }
	
private:
	 Resource* res_;
};

std::set<Resource*> ResourceList;

bool ResourceExists( const WeakHandle& res )
{
	return res->dataExists();
}

StrongHandle MakeResource()
{
	Resource* res = new Resource();
	ResourceList.insert( res );
	return res;
}

void DeleteResource( const WeakHandle& res )
{
	res->deleteData();
	
	ResourceList.erase( res.getResource() );
}

bool UserPassResource( const WeakHandle& res )
{
	// some stuff happens here
	return true;
}

bool EnginePassResource( const WeakHandle& res )
{
	bool b = ResourceExists( res );
	return b;
}


int main(int argc, const char* argv[])
{
	int Count = argc > 1 ? atoi(argv[1]) : 0;
	if (Count <= 0)
		Count = 1000000;
	
	std::cout << "Running " << Count << " iterations\n";
	
	for (int i = 0; i < Count; ++i)
	{
		StrongHandle res = MakeResource();       // Make it
		UserPassResource( res );   // One copy for the user
		EnginePassResource( res ); // One copy for the engine
		DeleteResource( res );     // Delete it
	}
}

#include <iostream>      // For debug output
#include <stdlib.h>

//#define DEBUG

class Resource
{
    // This class hold the actual resource
};


class ResourceOwner
{
public:
    ResourceOwner() : mResource( new Resource ), mCount( 1 )
    {
#ifdef DEBUG
        std::cout << "Created resource owner\n";
        std::cout << "Created resource\n";
#endif
    }

    ~ResourceOwner()
    {
        if ( mResource )
            throw "Data must be deleted via global function";
#ifdef DEBUG
        std::cout << "Destroyed resource owner\n";
#endif
    }

    void Delete()
    {
        if ( ! mResource )
            throw "Data has already been deleted";

        delete mResource;
        mResource = 0;

        Release();

#ifdef DEBUG
        std::cout << "Destroyed resource\n";
#endif
    }

    bool IsSet() const
    {
        return mResource;
    }

    void AddRef()
    {
        ++mCount;
#ifdef DEBUG
        std::cout << "Resource.AddRef reference count now " << mCount << "\n";
#endif
    }

    void Release()
    {
        --mCount;

#ifdef DEBUG
        std::cout << "Resource.Release reference count now " << mCount << "\n";
#endif

        if ( mCount == 0 )
        {
            delete mResource;
            delete this;
        }
    }

    // Need further member functions to access the resource
private:
    Resource* mResource;
    int  mCount;
};


class StrongHandle
{
public:
    StrongHandle() : mResource(0) {}

    StrongHandle( const StrongHandle& o ) : mResource( o.mResource )
    {
        if ( mResource )
            mResource->AddRef();
    }

    StrongHandle( ResourceOwner* h ) : mResource( h )
    {
        if ( mResource )
            mResource->AddRef();
    }

    ~StrongHandle()
    {
        if ( mResource )
            mResource->Release();
    }

    StrongHandle& operator = ( const StrongHandle& o )
    {
        if ( o.mResource )
            o.mResource->AddRef();

        if ( mResource )
            mResource->Release();

        mResource = o.mResource;

        return *this;
    }

private:
    ResourceOwner* mResource;

    friend class WeakHandle;
};


class WeakHandle
{
public:
    WeakHandle( const StrongHandle& sh ) : mResource( sh.mResource )
    {
        if ( !mResource )
            throw "Invalid resource";
    }

    ResourceOwner* operator -> () const
    {
        return mResource;
    }
private:
    ResourceOwner* mResource;
};


bool ResourceExists( const WeakHandle h )
{
    return h->IsSet();
}

StrongHandle MakeResource()
{
    ResourceOwner* h = new ResourceOwner();
#ifdef DEBUG
    std::cout << "Resource was allocated at " << (void*)h << "\n";
#endif
    return h;
}

void DeleteResource( const WeakHandle h )
{
    h->Delete();
}


bool UserPassResource( const StrongHandle h )
{
    // some stuff happens here
    return true;
}

bool EnginePassResource( const WeakHandle h )
{
    bool b = ResourceExists( h );
    return b;
}


int main(int argc, const char* argv[])
{
    int Count = argc > 1 ? atoi(argv[1]) : 0;
    if (Count <= 0)
        Count = 1000000;

    std::cout << "Running " << Count << " iterations\n";

    for (int i = 0; i < Count; ++i)
    {
        StrongHandle h = MakeResource();        // Make it
        UserPassResource( h );                  // One copy for the user
        EnginePassResource( h );                // One copy for the engine
        DeleteResource( h );                    // Delete it
    }
}

#include <iostream>      // For debug output
#include <stdlib.h>

//#define DEBUG

class Resource
{
    // This class hold the actual resource
};


class ResourceOwner
{
public:
    ResourceOwner() : mResource( new Resource ), mCount( 1 )
    {
#ifdef DEBUG
        std::cout << "Created resource owner\n";
        std::cout << "Created resource\n";
#endif
    }

    ~ResourceOwner()
    {
        if ( mResource )
            throw "Data must be deleted via global function";
#ifdef DEBUG
        std::cout << "Destroyed resource owner\n";
#endif
    }

    void Delete()
    {
        if ( ! mResource )
            throw "Data has already been deleted";

        delete mResource;
        mResource = 0;

        Release();

#ifdef DEBUG
        std::cout << "Destroyed resource\n";
#endif
    }

    bool IsSet() const
    {
        return mResource;
    }

    void AddRef()
    {
        ++mCount;
#ifdef DEBUG
       std::cout << "Resource.AddRef reference count now " << mCount << "\n";
#endif
    }

    void Release()
    {
       --mCount;

#ifdef DEBUG
       std::cout << "Resource.Release reference count now " << mCount << "\n";
#endif

       if ( mCount == 0 )
       {
            delete mResource;
            delete this;
       }
    }

    // Need further member functions to access the resource
private:
    Resource* mResource;
    int  mCount;
};


class WeakHandle
{
public:
    ResourceOwner* operator -> () const
    {
        if ( ! mResource )
            throw "Handle is not set and cannot be dereferenced\n";

        return mResource;
    }

    bool IsSet() const
    {
        return mResource ? mResource->IsSet() : false;
    }

protected:
    WeakHandle( ResourceOwner* resource = 0) : mResource( resource )
    {
#ifdef DEBUG
        std::cout << "Constructed WeakHandle\n";
#endif
    }

    ResourceOwner* mResource;
};


class StrongHandle : public WeakHandle
{
public:
    StrongHandle() : WeakHandle(0) {}

    StrongHandle( ResourceOwner* r ) : WeakHandle( r )
    {
        if ( IsSet() )
            mResource->AddRef();

#ifdef DEBUG
        std::cout << "Constructed StrongHandle\n";
#endif
    }

    StrongHandle( const StrongHandle& h ) : WeakHandle( h )
    {
#ifdef DEBUG
        std::cout << "Copied StrongHandle\n";
#endif

        if ( IsSet() )
            mResource->AddRef();
    }

    ~StrongHandle()
    {
        if ( IsSet() )
            mResource->Release();
#ifdef DEBUG
        std::cout << "Destroyed StrongHandle\n";
#endif
    }

    StrongHandle& operator = ( const StrongHandle& h )
    {
        if ( h.IsSet() )
            h.mResource->AddRef();

        if ( IsSet() )
            mResource->Release();

        mResource = h.mResource;

#ifdef DEBUG
        std::cout << "Assigned StrongHandle\n";
#endif
        return *this;
    }
};


bool ResourceExists( const WeakHandle h )
{
    return h->IsSet();
}

StrongHandle MakeResource()
{
    ResourceOwner* h = new ResourceOwner();
#ifdef DEBUG
    std::cout << "Resource was allocated at " << (void*)h << "\n";
#endif
    return h;
}

void DeleteResource( const WeakHandle h )
{
    h->Delete();
}


bool UserPassResource( const StrongHandle h )
{
    // some stuff happens here
    return true;
}

bool EnginePassResource( const WeakHandle h )
{
    bool b = ResourceExists( h );
    return b;
}


int main(int argc, const char* argv[])
{
    int Count = argc > 1 ? atoi(argv[1]) : 0;
    if (Count <= 0)
        Count = 1000000;

    std::cout << "Running " << Count << " iterations\n";

    for (int i = 0; i < Count; ++i)
    {
        StrongHandle h = MakeResource();        // Make it
        UserPassResource( h );                  // One copy for the user
        EnginePassResource( h );                // One copy for the engine
        DeleteResource( h );                    // Delete it
    }
}

hero = LoadObject("mupkidz.x")
PositionObject(hero, x, y, z)