typedef struct tagRECT
{
    LONG    left;
    LONG    top;
    LONG    right;
    LONG    bottom;
} RECT, *PRECT, NEAR *NPRECT, FAR *LPRECT;

   t_struct = add_structure_item();
   (*t_struct) = HIClass(NAME(f_RECT), sizeof(RECT));
   t_struct->add_item(0)->set(NAME(f_left), h_Int);
   t_struct->add_item(4)->set(NAME(f_top), h_Int);
   t_struct->add_item(8)->set(NAME(f_right), h_Int);
   t_struct->add_item(12)->set(NAME(f_bottom), h_Int);

typedef unsigned int uint32;
#define DWORD unsigned int

    uint32 myint1; 
    DWORD myint2;

#define __DESTRUCTOR(ty, ptr)   (ptr)->~ty()
#define __CONSTRUCTOR(ty, ptr)  (*ptr) = ty()
#define _vector_start _vector_data
#define _vector_capacity (_vector_end - _vector_start)
#define _vector_size (_current - _vector_start)
 
template 
class tVector
{
 
public:
 
        inline tVector() : _vector_data((T*) new char[sizeof(T) * 1]),
        _current(_vector_start), _vector_end(_vector_data + 1){}
 
        inline tVector(int nElements) : _vector_data(new char[sizeof(T) * nElements]),  
        _current(&_vector_data[nElements]), _vector_end(_current){}
       
        inline tVector(int nElements, const T& val) : _vector_data((T*) new char[sizeof(T) * nElements]), _vector_end(_vector_data + nElements){
                for(_current = _vector_data;_current != _vector_end;){*_current++ = val;}
        }
 
        inline tVector(tVector &object){
                if((_vector_capacity) < object.size()) allocate(object.size());
                memcpy(_vector_data, object._vector_data, object.size() * sizeof(T));
                _current = _vector_start + object.size();
        }
 
        inline operator= (tVector &object){
                if((_vector_capacity) < object.size()) allocate(object.size());
                memcpy(_vector_data, object._vector_data, object.size() * sizeof(T));
                _current = _vector_start + object.size();
        }
 
        inline ~tVector(){delete [](char*)_vector_data;}
 
        inline void push_back(const T &t){
                if(_current == _vector_end)double_size();*_current++ = t;
        }
 
        inline T& push_back_and_access(const T &t){
                if(_current == _vector_end)double_size();*_current++ = t;return _current[-1];
        }
 
        inline void pop_back(){_current -= (_current != _vector_start);}
        inline void pop_back_and_destroy(){
                if(_current != _vector_start){_current--;__DESTRUCTOR(T, _current]);}}
 
        inline void resize(size_t size){
                if((_vector_size) == size)return;
 
                T *it;
                if((_vector_size) < size){
                if((_vector_capacity) < size)
                {
                        T *_temp = (T*) new char[sizeof(T) * size];
                        _current = _temp + (_vector_size);
                        memcpy(_temp, _vector_data, (unsigned int)((char*)_vector_end - (char*)_vector_start));
                        _vector_end = (_temp + size);
                        delete [] (char*)_vector_data;_vector_data = _temp;return;
                }else
                {
                        it = _current;
                        _current = (_vector_start + size);
                        for(;it < _current;it++)__CONSTRUCTOR(T, it);
                }}
                else
                {
                        it = _current;
                        _current = (_vector_start + size);
 
                        if(it != _current)
                        do{it--;__DESTRUCTOR(T, it);}while(it != _current);
 
                }
        }
 
        inline void resize(size_t size, const T& val){
                if((_vector_size) == size)return;
 
                T *it;
                if((_vector_size) < size){
                if((_vector_capacity) < size)
                {
                        T *_temp = (T*) new char[sizeof(T) * size];
                        _current = _temp + (_vector_size);
                        memcpy(_temp, _vector_data, (unsigned int)((char*)_vector_end - (char*)_vector_start));
                        _vector_end = (_temp + size);
                        delete [] (char*)_vector_data;_vector_data = _temp;return;
                }else
                {
                        it = _current;
                        _current = (_vector_start + size);
                        for(;it < _current;)*it++ = val;
                }}
                else
                {
                        it = _current;
                        _current = (_vector_start + size);
 
                        if(it != _current)
                        do{it--;__DESTRUCTOR(T, it);}while(it != _current);
 
                }
        }
 
        inline T* insert(T * pos, const T &val){
                if(pos >= _current)return 0;
                unsigned int _pos = (pos - _vector_start);
                if(_current == _vector_end)
                        {double_size();pos = _vector_start + _pos;}
 
                for(T *it = _current++;it != pos;)*it-- = it[-1];
                *pos = val;return pos;
        }
 
        inline void insert(T * pos, size_t n, const T &val){
                if(pos >= _current)return;
                unsigned int _pos = (pos - _vector_start);
               
                _current += n;
                if(_current >= _vector_end)
                        {double_size();pos = _vector_start + _pos;}
 
                T *end = pos + n;
                for(T *it = _current - n - 1;it >= pos;)
                                it[n] = *it--;
 
                for(;pos != end;)*pos++ = val;                 
        }
 
        inline void insert(T * pos, T* first, T *last){
                if(pos >= _current || first >= last)return;
                unsigned int _pos = (pos - _vector_start);
               
                _current += (last - first);
                if(_current >= _vector_end)
                        {double_size();pos = _vector_start + _pos;}
 
                int n =  (last - first);
                T *end = pos + n;
                for(T *it = _current - n - 1;it >= pos;)
                                it[n] = *it--;
                for(;pos != end;)*pos++ = *first++;                    
        }
 
        inline void assign(size_t size, const T &val){if(!size)return;
                if(_current != _vector_start)
                        for(T *it = _vector_data;it < _current;it++)__DESTRUCTOR(T, it);
                if((_vector_capacity) < size)allocate(size);
                _current = _vector_start + size;
 
                for(T *it = _vector_start;it < _current;){*it++ = val;}
        }
 
        inline void shrink_to_fit(){
        if(_current == _vector_end || _current == _vector_start)return;
 
                T *_temp = (T*) new char[sizeof(T) * (_vector_size)];
                memcpy(_temp, _vector_data, (unsigned int)((char*)_current - (char*)_vector_start));
                _current = _temp + (_vector_size);
                delete [] (char*)_vector_data;_vector_data = _temp;_vector_end = _current;
        }
 
        inline void reverse(int count = 0){
                size_t half_size = ((unsigned int)(_vector_size)) / 2;
                if(count && count < half_size)half_size = count;
                char temp[sizeof(T)]; //avoid constructors
                T*_end = _vector_end - 1;
 
        for(int i = 0;i < half_size;i++)
                {
                        *((T*)temp) = (_vector_start)[i];
                        (_vector_start)[i] = (_end)[-i];
                        (_end)[-i] = *((T*)temp);
                }
        }
 
        inline void erase(unsigned int pos){
                if(_current == _vector_start || pos >= (_vector_size))return;
                __DESTRUCTOR(T, &_vector_data[pos]);
 
                for(T *it = &_vector_data[pos + 1];it < _current;){it[-1] = *it++;}
                _current--;
        }
 
        inline void erase(T *pos){
                if(pos >= _current)return;
                __DESTRUCTOR(T, pos);
 
                T *__current = _current--;
                for(pos++;pos < __current;){pos[-1] = *pos++;}
        }
 
        inline void erase(T *first, T *last){
                if(last >= _current)return;
 
                for(T *it = first;it < last;it++)
                        {__DESTRUCTOR(T, it);}
 
                T *__current = _current;
                _current -= (last - first);
                for(;it < __current;){*first++ = *it++;}
 
        }
 
        inline void erase(unsigned int first, unsigned int last){
                unsigned int range = last - first;
                if(first >= last || (_current - range < _vector_start) || last >= (_vector_size))return;
 
                T *end = &_vector_data[last];
                for(T *it = &_vector_data[first];it < end;it++)
                        {__DESTRUCTOR(T, it);}
                range = -range;
 
                for(;it < _current;){it[range] = *it++;}
                _current += range; //it's negative
        }
 
 
        inline void swap(tVector  &obj){
                T *__current = _current;
                T *__vector_start = _vector_start;
                T *__vector_end = _vector_end;
                _current = obj._current;
                _vector_start = obj._vector_start;
                _vector_end = obj._vector_end;
                obj._current = __current;
                obj._vector_start = __vector_start;
                obj._vector_end = __vector_end;
        }
 
        inline void clear(bool bDestroy = false){
                if(bDestroy)for(T *it = _vector_data;it < _current;it++){__DESTRUCTOR(T, it);}
        _vector_end = _vector_start;_current = _vector_data;}
 
        inline void reset(){_current = _vector_start;}
        inline void reserve(size_t max){if(max > (_vector_capacity))new_size(max);}
        inline size_t size() const {return _vector_size;}
        //inline void set_size(size_t new_size){if(new_size < vector_capacity)_current = _vector_start + new_size;}
        inline T& at(unsigned int index) const {return _vector_start[index];}
        inline bool empty(){return ((_vector_capacity) <= 0);}<br />        inline T* data() const {return _vector_start;}
        inline T* begin() const {return _vector_start;}
        inline T* end() const {return _current;}
        inline T& front() const {return *_vector_start;}
        inline T& back() const {return _current[-1];}
        inline size_t capacity() const {return (_vector_capacity);}
        T& operator[] (unsigned int index) const {return _vector_start[index];}
        inline size_t max_size() const {allocator obj;return obj.max_size();}
 
    _PROTECTED :
            T *_vector_data, *_current, *_vector_end;
 
        private :
 
        inline void allocate(size_t size){
                delete [] _vector_data;
                _vector_data = (T*) new char[sizeof(T) * size];
                _current = _vector_start;
                _vector_end = (_vector_start + size);
        }
 
 
        inline void double_size(){
                T *_temp = (T*) new char[sizeof(T) * (unsigned int)(_vector_capacity) * 2];
                _current = _temp + (_vector_capacity);
                memcpy(_temp, _vector_data, (unsigned int)((char*)_vector_end - (char*)_vector_data));
                _vector_end = _temp + (_vector_capacity) * 2;
                delete [] (char*)_vector_data;_vector_data = _temp;
        }
 
                        inline void new_size(size_t size)
        {
                T *_temp = (T*) new char[sizeof(T) * size];
                        _current = _temp + (_vector_size);
                        memcpy(_temp, _vector_data, (unsigned int)((char*)_vector_end - (char*)_vector_data));
                        _vector_end = _temp + size;
                        delete [] (char*)_vector_data;_vector_data = _temp;
        }
};
#undef __DESTRUCTOR
#undef __CONSTRUCTOR
#undef _array_start
#undef _vector_capacity
#undef _vector_size

bool FrameFunc()
{	
chr=hge->Input_GetChar();
	c=a+b;
	if (hge->Input_GetKeyState(HGEK_F1))
	{
		
	char res[10](" ");
		_itoa_s(c,res,10);
		if (equ(s,res))
		{
			points1+=1;
			hge->Effect_PlayEx(snd,100,0,1,0);
			a=hge->Random_Int(1,9);
			b=hge->Random_Int(1,9);
			
		}
		else
		{
			points2+=1;
			a=hge->Random_Int(1,9);
			b=hge->Random_Int(1,9);
		}
		clear(s);
		Sleep(800);

	}
	if (hge->Input_GetKeyState(HGEK_F2))
	{
		
	char res[10](" ");
		_itoa_s(c,res,10);
		if (equ(s,res))
		{
			points2+=1;
			hge->Effect_PlayEx(snd,100,0,1,0);
			a=hge->Random_Int(1,9);
			b=hge->Random_Int(1,9);
			
		}
		else
		{
			points1+=1;
			a=hge->Random_Int(1,9);
			b=hge->Random_Int(1,9);
		}
		clear(s);
		Sleep(800);

	}
	input();

	get();

	if (hge->Input_GetKeyState(HGEK_ESCAPE)) return true;
	return false;
}

• What was the reasoning behind using D3DPOOL_MANAGED for texture creation?
  
• Is it safe to modify HGE to use D3DPOOL_SYSTEMMEM instead? Would there be any negative downsides?
  
• Other than using a slow, manual texture lock/copy/unlock operation, how could I copy HTARGET data to a newly created D3DPOOL_MANAGED texture?

EDIT: I believe something LIKE THIS is what I'm going for

//------------------------------------------------------------
// Cosmos Game xD v0.0001f
//------------------------------------------------------------
#pragma comment (lib, "hge.lib")
#pragma comment (lib, "hgehelp.lib")

//Include-----------------------------------------------------
#include 
#include 
#include 
#include 
#include 

//Globals-----------------------------------------------------
HGE* hge = NULL;

const float SCR_WIDTH  = 800.0f;
const float SCR_HEIGHT = 600.0f;

bool fire = false;

hgeSprite* g_sPlayer = NULL;
hgeVector  g_vPlayer = hgeVector(SCR_WIDTH/2, SCR_HEIGHT-30);

hgeAnimation* g_aFire = NULL;
hgeVector     g_vFire = hgeVector(0, 0);

hgeSprite* g_sBullet = NULL;
hgeVector  g_vBullet = hgeVector(0, 0);
hgeVector  g_vSpeedB = hgeVector(0, -1.0);

HTEXTURE   g_tPlayer = NULL;
HTEXTURE   g_tFire   = NULL;
HTEXTURE   g_tBullet = NULL;

//Frame-------------------------------------------------------
bool Frame()
{
	float dt = hge->Timer_GetDelta();	// no comments
	float lol;	// no problem :)

	// Set player coordinate
	hge->Input_GetMousePos(&g_vPlayer.x, &lol);

	// Vector of fire
	g_vFire = hgeVector(g_vPlayer.x, SCR_HEIGHT-71);

	// Vector of bullet
	g_vBullet = hgeVector(g_vFire.x, g_vFire.y-19);

	// Fire
	if(hge->Input_GetKeyState(HGEK_LBUTTON))
	{
		fire = true;
		g_aFire->Resume();
		
		g_vBullet += g_vSpeedB;
	}
	else
	{
		fire = false;
		g_aFire->Stop();
	}
	
	// Update fire animation
	g_aFire->Update(dt);

	// Exit
	if(hge->Input_GetKeyState(HGEK_ESCAPE)) return true;

	return false;
}
//Render------------------------------------------------------
bool Render()
{
	hge->Gfx_BeginScene();
	hge->Gfx_Clear(0x0);

	// Render player
	g_sPlayer->Render(g_vPlayer.x, g_vPlayer.y);

	// Render fire
	if(fire)
	{
		g_aFire->Render(g_vFire.x, g_vFire.y);
	}

	g_sBullet->Render(g_vBullet.x, g_vBullet.y);

	hge->Gfx_EndScene();

	return false;
}

//WinMain-----------------------------------------------------
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
	hge = hgeCreate(HGE_VERSION);

	hge->System_SetState(HGE_USESOUND, false);
	//hge->System_SetState(HGE_HIDEMOUSE, false);
	hge->System_SetState(HGE_WINDOWED, true);
	hge->System_SetState(HGE_LOGFILE, "file.log");
	hge->System_SetState(HGE_FRAMEFUNC, Frame);
	hge->System_SetState(HGE_RENDERFUNC, Render);
	hge->System_SetState(HGE_FPS, HGEFPS_VSYNC);

	if(hge->System_Initiate())
	{
		// Player
		g_tPlayer = hge->Texture_Load("..\\player.png");
		g_sPlayer = new hgeSprite(g_tPlayer, 0, 0, 52.0, 36.0);
		g_sPlayer->SetHotSpot(26.0, 18.0);

		// Fire
		g_tFire = hge->Texture_Load("..\\plsm.png");
		g_aFire = new hgeAnimation(g_tFire, 6, 21, 0, 0, 13.0, 39.0);
		g_aFire->SetHotSpot(6.5, 19.5);

		// Bullet
		g_tBullet = hge->Texture_Load("..\\bullet.png");
		g_sBullet = new hgeSprite(g_tBullet, 0, 0, 3.0, 11.0);
		g_sBullet->SetHotSpot(1.5, 5.5);

		hge->System_Start();

		// Free resource
		hge->Texture_Free(g_tPlayer);
		hge->Texture_Free(g_tFire);
		hge->Texture_Free(g_tBullet);
		delete g_sPlayer;
		delete g_aFire;
		delete g_sBullet;
	}

	hge->System_Shutdown();
	hge->Release();

	return 0;
}

gui->AddCtrl(new cGUI(MS_PLAY,    fntMenu, onsnd, pshsnd, hge->System_GetState(HGE_SCREENWIDTH)/2.0f - fntMenu->GetStringWidth("НОВАЯ ИГРА")/2.0f, hge->System_GetState(HGE_SCREENHEIGHT)/2.0f-60, "НОВАЯ ИГРА"));

if(hge->Input_GetKeyState(HGEK_LBUTTON))
	{			
		float ix, iy, iw, ih;
		float x1, x2, y1, y2;
		float mx, my;
		bool getobj = false;

		one->GetTextureRect(&ix,&iy,&iw,&ih);
		hge->Input_GetMousePos(&mx,&my);

		x1 = ix; y1 = iy; x2 = ix+iw; y2 = iy+ih;

		if(x2>mx && x1		{
			cout << "if x\n";<br />			if(y2>my && y1			{
				getobj = true;
				
				cout << "getobj = true!\n";<br />			}
			cout << "getobj Y fail\n";<br />		}
	}

class Object
{
	public:
		int x,y;
		hgeSprite *spr;
		hgeRect *BBox;
		HTEXTURE tex;
		char *str;

		Object(int _x, int _y, char *_imageFile)
		{
			x=_x;
			y=_y;
			str = new char[strlen(_imageFile)+1];
			strcpy_s(str, strlen(_imageFile)+1, _imageFile);

			tex = hge->Texture_Load(str);
			spr = new hgeSprite(tex, 0, 0, 100, 70);
			BBox = new hgeRect(_x, _y,  _x + spr->GetWidth(), _y + spr->GetHeight());
		}

		Object(const Object &obj)
		{
			x = obj.x;
			x = obj.y;
			str = new char[strlen(obj.str)+1];
			strcpy_s(str, strlen(obj.str)+1, obj.str);

			tex = obj.tex;
			spr = new hgeSprite(*obj.spr);
			BBox = new hgeRect(*obj.BBox);
		}

		~Object()
		{
			//hge->Texture_Free(texture);//Вызывает ошибку
			delete BBox;
			delete spr;		
			delete [] str;
		}

		void Render()
		{
			spr->Render(x,y);
		}
};
list

bool RenderFunc()
{
	hge->Gfx_BeginScene();
	hge->Gfx_Clear(0);

                int k = 100; int j = 100;
	for(list 

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
	hge = hgeCreate(HGE_VERSION);

	.
                .
                .
                .

	if(hge->System_Initiate())
	{
		ObjectPtr = new Object(100, 100,"object.png"); //(1#)
		List.push_back(*ObjectPtr);//Запускается нормально, но завершается аварийно  //(2#)
		List.push_back(Object(100, 200, "object.png"));//Запускается с ошибкой  //(3#)
		

		hge->System_Start();

		hge->Effect_Free(snd);
	}
	
	
	delete ObjectPtr; //(4#)

	

	hge->System_Shutdown();
	hge->Release();
	return 0;
}