Начну с того что я как я любитель билдоман и уже вошла в привычку моя поисковая сноровка, и она меня не подвила я начал свой день с того что мне захотелось найти в исходниках X-Ray те строки которые отвечают за использование процессора и я начал эти поиски и они прошли недолго часика так за 4-5 в поиске через Notepad++ я сначала нашел вот эти подозрительные строки.

Немного посмотрев на них я подумал может это ограничение использование видео памяти но после того как я тут отписался меня в этом переубедили Пост но главное суть я понял. Немного полистав в глубь x_ray.cpp я увидел вот это:
И тут я немного погуглил и сказав не может быть начал быстренько собирать сорцы но при этом поменяв цифру 1 на 2 и был приятно удивлен мой гаджет на боковой панели показал усердное использование второго ядра, не долго думая я поставил цифру 0 и попробовав я увидел свое счастье два процессора работают и диспетчер задач показывает что xrEngine использует 70% ЦП УРА!!! Можно танцевать!!!

#ifdef DEBUG_MEMORY_NAME
// new(0)
template <class T>
IC T* xr_new ()
{
T* ptr = (T*)Memory.mem_alloc(sizeof(T), typeid(T).name());
return new (ptr) T();
}
// new(1)
template <class T, class P1>
IC T* xr_new (const P1& p1) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T), typeid(T).name());
return new (ptr) T(p1);
}
// new(2)
template <class T, class P1, class P2>
IC T* xr_new (const P1& p1, const P2& p2) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T), typeid(T).name());
return new (ptr) T(p1,p2);
}
// new(3)
template <class T, class P1, class P2, class P3>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T), typeid(T).name());
return new (ptr) T(p1,p2,p3);
}
// new(4)
template <class T, class P1, class P2, class P3, class P4>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T), typeid(T).name());
return new (ptr) T(p1,p2,p3,p4);
}
// new(5)
template <class T, class P1, class P2, class P3, class P4, class P5>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T), typeid(T).name());
return new (ptr) T(p1,p2,p3,p4,p5);
}
// new(6)
template <class T, class P1, class P2, class P3, class P4, class P5, class P6>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T), typeid(T).name());
return new (ptr) T(p1,p2,p3,p4,p5,p6);
}
// new(7)
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T), typeid(T).name());
return new (ptr) T(p1,p2,p3,p4,p5,p6,p7);
}
// new(8)
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7, const P8& p8) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T), typeid(T).name());
return new (ptr) T(p1,p2,p3,p4,p5,p6,p7,p8);
}
// new(9)
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7, const P8& p8, const P8& p9) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T), typeid(T).name());
return new (ptr) T(p1,p2,p3,p4,p5,p6,p7,p8,p9);
}
#else // DEBUG_MEMORY_NAME
// new(0)
template <class T>
IC T* xr_new ()
{
T* ptr = (T*)Memory.mem_alloc(sizeof(T));
return new (ptr) T();
}
// new(1)
template <class T, class P1>
IC T* xr_new (const P1& p1) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T));
return new (ptr) T(p1);
}
// new(2)
template <class T, class P1, class P2>
IC T* xr_new (const P1& p1, const P2& p2) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T));
return new (ptr) T(p1,p2);
}
// new(3)
template <class T, class P1, class P2, class P3>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T));
return new (ptr) T(p1,p2,p3);
}
// new(4)
template <class T, class P1, class P2, class P3, class P4>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T));
return new (ptr) T(p1,p2,p3,p4);
}
// new(5)
template <class T, class P1, class P2, class P3, class P4, class P5>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T));
return new (ptr) T(p1,p2,p3,p4,p5);
}
// new(6)
template <class T, class P1, class P2, class P3, class P4, class P5, class P6>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T));
return new (ptr) T(p1,p2,p3,p4,p5,p6);
}
// new(7)
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T));
return new (ptr) T(p1,p2,p3,p4,p5,p6,p7);
}
// new(8)
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7, const P8& p8) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T));
return new (ptr) T(p1,p2,p3,p4,p5,p6,p7,p8);
}
// new(9)
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
IC T* xr_new (const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7, const P8& p8, const P8& p9) {
T* ptr = (T*)Memory.mem_alloc(sizeof(T));
return new (ptr) T(p1,p2,p3,p4,p5,p6,p7,p8,p9);
}
#endif // DEBUG_MEMORY_NAME

#ifndef _PURE_H_AAA_
#define _PURE_H_AAA_

// messages
#define REG_PRIORITY_LOW 0x11111111ul
#define REG_PRIORITY_NORMAL 0x22222222ul
#define REG_PRIORITY_HIGH 0x33333333ul
#define REG_PRIORITY_CAPTURE 0x7ffffffful
#define REG_PRIORITY_INVALID 0xfffffffful

typedef void __fastcall RP_FUNC (void *obj);
#define DECLARE_MESSAGE(name) extern ENGINE_API RP_FUNC rp_##name; class ENGINE_API pure##name { public: virtual void On##name(void)=0; }
#define DECLARE_RP(name) void __fastcall rp_##name(void *p) { ((pure##name *)p)->On##name(); }

DECLARE_MESSAGE(Frame);
DECLARE_MESSAGE(Render);
DECLARE_MESSAGE(AppActivate);
DECLARE_MESSAGE(AppDeactivate);
DECLARE_MESSAGE(AppStart);
DECLARE_MESSAGE(AppEnd);
DECLARE_MESSAGE(DeviceReset);

//-----------------------------------------------------------------------------
struct _REG_INFO {
void* Object;
int Prio;
u32 Flags;
};

ENGINE_API extern int __cdecl _REG_Compare(const void *, const void *);

template <class T> class CRegistrator // the registrator itself
{
friend ENGINE_API int __cdecl _REG_Compare(const void *, const void *);
public:
xr_vector<_REG_INFO> R;
// constructor
struct {
u32 in_process :1;
u32 changed :1;
};
CRegistrator() { in_process=false; changed=false;}

//
void Add (T *obj, int priority=REG_PRIORITY_NORMAL, u32 flags=0)
{
#ifdef DEBUG
VERIFY (priority!=REG_PRIORITY_INVALID);
VERIFY (obj);
for (u32 i=0; i<R.size(); i++) VERIFY( !((R[i].Prio!=REG_PRIORITY_INVALID)&&(R[i].Object==(void*)obj)) );
#endif
_REG_INFO I;
I.Object =obj;
I.Prio =priority;
I.Flags =flags;
R.push_back (I);

if(in_process) changed=true;
else Resort ( );
};
void Remove (T *obj)
{
for (u32 i=0; i<R.size(); i++) {
if (R[i].Object==obj) R[i].Prio = REG_PRIORITY_INVALID;
}
if(in_process) changed=true;
else Resort ( );
};
void Process(RP_FUNC *f)
{
in_process = true;
if (R.empty()) return;
if (R[0].Prio==REG_PRIORITY_CAPTURE) f(R[0].Object);
else {
for (u32 i=0; i<R.size(); i++)
if(R[i].Prio!=REG_PRIORITY_INVALID)
f(R[i].Object);

}
if(changed) Resort();
in_process = false;
};
void Resort (void)
{
qsort (&*R.begin(),R.size(),sizeof(_REG_INFO),_REG_Compare);
while ((R.size()) && (R[R.size()-1].Prio==REG_PRIORITY_INVALID)) R.pop_back();
if (R.empty()) R.clear ();
changed = false;
};
};

#endif