Controller::Controller(const ControllerResource* cr, SceneGraph& sg, UnitId id, PxPhysics* physics, PxControllerManager* manager)
: m_resource(cr)
, m_scene_graph(sg)
, _unit_id(id)
, m_manager(manager)
, m_controller(NULL)
{
TransformInstance ti = sg.get(id);
const Vector3 pos = sg.world_position(ti);
PxCapsuleControllerDesc desc;
desc.climbingMode = PxCapsuleClimbingMode::eCONSTRAINED;
desc.nonWalkableMode = PxCCTNonWalkableMode::eFORCE_SLIDING;
desc.radius = cr->radius;
desc.height = cr->height;
desc.slopeLimit = cos(cr->slope_limit);
desc.stepOffset = cr->step_offset;
desc.contactOffset = cr->contact_offset;
desc.upDirection = PxVec3(0.0, 1.0, 0.0);
desc.material = physics->createMaterial(0.5f, 0.5f, 0.5f);
desc.position = PxExtendedVec3(pos.x, pos.y, pos.z);
desc.reportCallback = &m_callback;
CE_ASSERT(desc.isValid(), "Capsule is not valid");
m_controller = manager->createController(desc);
CE_ASSERT(m_controller, "Failed to create controller");
}
PoolAllocator::PoolAllocator(Allocator& backing, uint32_t num_blocks, uint32_t block_size, uint32_t block_align)
: _backing(backing)
, _start(NULL)
, _freelist(NULL)
, _block_size(block_size)
, _block_align(block_align)
, _num_allocations(0)
, _allocated_size(0)
{
CE_ASSERT(num_blocks > 0, "Unsupported number of blocks");
CE_ASSERT(block_size > 0, "Unsupported block size");
CE_ASSERT(block_align > 0, "Unsupported block alignment");
uint32_t actual_block_size = block_size + block_align;
uint32_t pool_size = num_blocks * actual_block_size;
char* mem = (char*) backing.allocate(pool_size, block_align);
// Initialize intrusive freelist
char* cur = mem;
for (uint32_t bb = 0; bb < num_blocks - 1; bb++)
{
uintptr_t* next = (uintptr_t*) cur;
*next = (uintptr_t) cur + actual_block_size;
cur += actual_block_size;
}
uintptr_t* end = (uintptr_t*) cur;
*end = (uintptr_t) NULL;
_start = mem;
_freelist = mem;
}
//-----------------------------------------------------------------------------
uint32_t Heightfield::coords_to_index(uint32_t x, uint32_t y) const
{
CE_ASSERT(x < m_width, "X coordinates beyond heightfield width");
CE_ASSERT(y < m_height, "Y coordinates beyond heightfield height");
return m_width * y + x;
}
//-----------------------------------------------------------------------------
DiskFile* Filesystem::open(const char* relative_path, FileOpenMode mode)
{
CE_ASSERT(exists(relative_path), "File does not exist: %s", relative_path);
CE_ASSERT(is_file(relative_path), "File is not a regular file: %s", relative_path);
return CE_NEW(m_allocator, DiskFile)(mode, os_path(relative_path));
}
//-----------------------------------------------------------------------------
Filesystem::Filesystem(const char* root_path)
{
CE_ASSERT(root_path != NULL, "Root path must be != NULL");
CE_ASSERT(os::is_absolute_path(root_path), "Root path must be absolute");
string::strncpy(m_root_path, root_path, MAX_PATH_LENGTH);
}
static void TAU32_CALLBACK_TYPE ce_on_receive
(TAU32_UserContext *pContext, TAU32_UserRequest *req)
{
ce_buf_item_t *item = (ce_buf_item_t *)req;
ce_chan_t *c;
ce_board_t *b;
unsigned int error;
int len;
ENTER ();
if (!req || !req->sys) {
EXIT ();
}
c = (ce_chan_t *)req->sys;
b = c->board;
len = req->Io.Rx.Received;
error = req->ErrorCode;
c->rintr++;
if (error == TAU32_SUCCESSFUL) {
if (req->Io.Rx.FrameEnd) {
c->ipkts++;
} else {
CE_DDK_DEBUG (b, c, ("No FrameEnd\n"));
/* probably do something in some cases*/
}
c->ibytes += len;
if (c->receive)
c->receive (c, item->buf, len);
} else if (error & TAU32_ERROR_BUS) {
c->overrun++;
if (c->error)
c->error (c, CE_OVERRUN);
} else {
CE_DDK_DEBUG (b, c, ("Another receive error: %x\n", error));
/* Do some procesing */
}
CE_ASSERT (!req->pInternal);
CE_ENQUEUE (c->rx_queue, req);
while (c->rx_queue) {
CE_DEQUEUE (c->rx_queue, req);
CE_ASSERT (req);
item = (ce_buf_item_t *)req;
req->Command = TAU32_Rx_Data;
req->Io.Rx.Channel = c->num;
req->pCallback = ce_on_receive;
req->Io.Rx.BufferLength = BUFSZ+4;
req->Io.Rx.PhysicalDataAddress = item->phys;
if (!TAU32_SubmitRequest (b->ddk.pControllerObject, req)) {
CE_DDK_DEBUG (b, c, ("RX submition failure\n"));
c->rx_pending--;
CE_ENQUEUE_HEAD (c->rx_queue, req);
break;
}
}
EXIT ();
}
void TCPSocket::set_timeout(u32 seconds)
{
struct timeval timeout;
timeout.tv_sec = seconds;
timeout.tv_usec = 0;
int err = setsockopt(_socket, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout));
CE_ASSERT(err == 0, "setsockopt: last_error(): %d", last_error());
err = setsockopt(_socket, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof(timeout));
CE_ASSERT(err == 0, "setsockopt: last_error(): %d", last_error());
CE_UNUSED(err);
}
//-----------------------------------------------------------------------------
Args::Args(int argc, char** argv, const char* shortopts, const ArgsOption* longopts) :
m_argc(argc),
m_argv(argv),
m_shortopts(shortopts),
m_longopts(longopts),
m_optind(1), // Do not consider argv[0]
m_scope(argc),
m_optarg(NULL)
{
CE_ASSERT(argv != NULL, "Argument vector must be != NULL");
CE_ASSERT(shortopts != NULL, "Short argument list must be != NULL");
// longopts could be NULL
}
void skip(u32 bytes)
{
#if CROWN_PLATFORM_POSIX
int err = fseek(_file, bytes, SEEK_CUR);
CE_ASSERT(err == 0, "fseek: errno = %d", errno);
#elif CROWN_PLATFORM_WINDOWS
DWORD err = SetFilePointer(_file, bytes, NULL, FILE_CURRENT);
CE_ASSERT(err != INVALID_SET_FILE_POINTER
, "SetFilePointer: GetLastError = %d"
, GetLastError()
);
#endif
CE_UNUSED(err);
}
void flush()
{
#if CROWN_PLATFORM_POSIX
int err = fflush(_file);
CE_ASSERT(err == 0, "fflush: errno = %d", errno);
#elif CROWN_PLATFORM_WINDOWS
BOOL err = FlushFileBuffers(_file);
CE_ASSERT(err != 0
, "FlushFileBuffers: GetLastError = %d"
, GetLastError()
);
#endif
CE_UNUSED(err);
}
void seek_to_end()
{
#if CROWN_PLATFORM_POSIX
int err = fseek(_file, 0, SEEK_END);
CE_ASSERT(err == 0, "fseek: errno = %d", errno);
#elif CROWN_PLATFORM_WINDOWS
DWORD err = SetFilePointer(_file, 0, NULL, FILE_END);
CE_ASSERT(err != INVALID_SET_FILE_POINTER
, "SetFilePointer: GetLastError = %d"
, GetLastError()
);
#endif
CE_UNUSED(err);
}
void seek(u32 position)
{
#if CROWN_PLATFORM_POSIX
int err = fseek(_file, (long)position, SEEK_SET);
CE_ASSERT(err == 0, "fseek: errno = %d", errno);
#elif CROWN_PLATFORM_WINDOWS
DWORD err = SetFilePointer(_file, position, NULL, FILE_BEGIN);
CE_ASSERT(err != INVALID_SET_FILE_POINTER
, "SetFilePointer: GetLastError = %d"
, GetLastError()
);
#endif
CE_UNUSED(err);
}
u32 read(void* data, u32 size)
{
CE_ASSERT(data != NULL, "Data must be != NULL");
#if CROWN_PLATFORM_POSIX
size_t bytes_read = fread(data, 1, size, _file);
CE_ASSERT(ferror(_file) == 0, "fread error");
return (u32)bytes_read;
#elif CROWN_PLATFORM_WINDOWS
DWORD bytes_read;
BOOL err = ReadFile(_file, data, size, &bytes_read, NULL);
CE_ASSERT(err == TRUE, "ReadFile: GetLastError = %d", GetLastError());
_eof = err && bytes_read == 0;
return bytes_read;
#endif
}
void* PoolAllocator::allocate(uint32_t size, uint32_t align)
{
CE_ASSERT(size == _block_size, "Size must match block size");
CE_ASSERT(align == _block_align, "Align must match block align");
CE_ASSERT(_freelist != NULL, "Out of memory");
uintptr_t next_free = *((uintptr_t*) _freelist);
void* user_ptr = _freelist;
_freelist = (void*) next_free;
_num_allocations++;
_allocated_size += _block_size;
return user_ptr;
}
u32 position()
{
#if CROWN_PLATFORM_POSIX
long pos = ftell(_file);
CE_ASSERT(pos != -1, "ftell: errno = %d", errno);
return (u32)pos;
#elif CROWN_PLATFORM_WINDOWS
DWORD pos = SetFilePointer(_file, 0, NULL, FILE_CURRENT);
CE_ASSERT(pos != INVALID_SET_FILE_POINTER
, "SetFilePointer: GetLastError = %d"
, GetLastError()
);
return (u32)pos;
#endif
}
ApkFile::ApkFile(AAssetManager* asset_manager, const char* path)
: File(FOM_READ)
, _asset(NULL)
{
_asset = AAssetManager_open(asset_manager, path, AASSET_MODE_RANDOM);
CE_ASSERT(_asset != NULL, "AAssetManager_open: failed to open %s", path);
}
void TCPSocket::set_reuse_address(bool reuse)
{
int optval = (int)reuse;
int err = setsockopt(_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&optval, sizeof(optval));
CE_ASSERT(err == 0, "setsockopt: last_error() = %d", last_error());
CE_UNUSED(err);
}
void ApkFile::read(void* buffer, size_t size)
{
CE_ASSERT_NOT_NULL(buffer);
size_t bytes_read = (size_t) AAsset_read(_asset, buffer, size);
CE_ASSERT(bytes_read == size, "AAsset_read: requested: %lu, read: %lu", size, bytes_read);
CE_UNUSED(bytes_read);
}
const void* ResourceManager::get(StringId64 type, StringId64 name)
{
const ResourcePair id = { type, name };
TempAllocator128 ta;
DynamicString type_str(ta);
DynamicString name_str(ta);
type.to_string(type_str);
name.to_string(name_str);
CE_ASSERT(can_get(type, name)
, "Resource not loaded #ID(%s-%s)"
, type_str.c_str()
, name_str.c_str()
);
CE_UNUSED(type_str);
CE_UNUSED(name_str);
if (_autoload && !sort_map::has(_rm, id))
{
load(type, name);
flush();
}
const ResourceEntry& entry = sort_map::get(_rm, id, ResourceEntry::NOT_FOUND);
return entry.data;
}
void ResourceManager::load(StringId64 type, StringId64 name)
{
ResourcePair id = { type, name };
ResourceEntry& entry = sort_map::get(_rm, id, ResourceEntry::NOT_FOUND);
if (entry == ResourceEntry::NOT_FOUND)
{
TempAllocator64 ta;
DynamicString type_str(ta);
DynamicString name_str(ta);
type.to_string(type_str);
name.to_string(name_str);
CE_ASSERT(_loader->can_load(type, name)
, "Can't load resource #ID(%s-%s)"
, type_str.c_str()
, name_str.c_str()
);
CE_UNUSED(type_str);
CE_UNUSED(name_str);
ResourceRequest rr;
rr.type = type;
rr.name = name;
rr.load_function = sort_map::get(_type_data, type, ResourceTypeData()).load;
rr.allocator = &_resource_heap;
rr.data = NULL;
_loader->add_request(rr);
return;
}
entry.references++;
}
void SceneGraph::allocate(uint32_t num)
{
CE_ASSERT(num > _data.size, "num > _data.size");
const uint32_t bytes = num * (0
+ sizeof(UnitId)
+ sizeof(Matrix4x4)
+ sizeof(Pose)
+ sizeof(TransformInstance) * 4);
InstanceData new_data;
new_data.size = _data.size;
new_data.capacity = num;
new_data.buffer = _allocator.allocate(bytes);
new_data.unit = (UnitId*)(new_data.buffer);
new_data.world = (Matrix4x4*)(new_data.unit + num);
new_data.local = (Pose*)(new_data.world + num);
new_data.parent = (TransformInstance*)(new_data.local + num);
new_data.first_child = (TransformInstance*)(new_data.parent + num);
new_data.next_sibling = (TransformInstance*)(new_data.first_child + num);
new_data.prev_sibling = (TransformInstance*)(new_data.next_sibling + num);
memcpy(new_data.unit, _data.unit, _data.size * sizeof(UnitId));
memcpy(new_data.world, _data.world, _data.size * sizeof(Matrix4x4));
memcpy(new_data.local, _data.local, _data.size * sizeof(Pose));
memcpy(new_data.parent, _data.parent, _data.size * sizeof(TransformInstance));
memcpy(new_data.first_child, _data.first_child, _data.size * sizeof(TransformInstance));
memcpy(new_data.next_sibling, _data.next_sibling, _data.size * sizeof(TransformInstance));
memcpy(new_data.prev_sibling, _data.prev_sibling, _data.size * sizeof(TransformInstance));
_allocator.deallocate(_data.buffer);
_data = new_data;
}
LinearAllocator::~LinearAllocator()
{
if (_backing)
_backing->deallocate(_physical_start);
CE_ASSERT(_offset == 0, "Memory leak of %ld bytes, maybe you forgot to call clear()?", _offset);
}
//-----------------------------------------------------------------------------
void Device::shutdown()
{
CE_ASSERT(_is_init, "Engine is not initialized");
// Shutdowns the game
_lua_environment->call_global("shutdown", 0);
_boot_package->unload();
destroy_resource_package(_boot_package);
CE_LOGD("Releasing lua system...");
lua_system::shutdown();
CE_DELETE(_allocator, _lua_environment);
CE_LOGD("Releasing material manager...");
material_manager::shutdown();
CE_LOGD("Releasing world manager...");
CE_DELETE(_allocator, _world_manager);
CE_LOGD("Releasing resource manager...");
CE_DELETE(_allocator, _resource_manager);
Bundle::destroy(_allocator, _resource_bundle);
_allocator.clear();
_is_init = false;
}
//-----------------------------------------------------------------------------
void GLContext::create_context()
{
m_win_context = wglCreateContext(GetDC(s_handle_window));
wglMakeCurrent(GetDC(s_handle_window), m_win_context);
CE_ASSERT(m_win_context != NULL, "Unable to create a rendering context.");
}
const ShaderData& ShaderManager::get(StringId32 id)
{
CE_ASSERT(sort_map::has(_shader_map, id), "Shader not found");
ShaderData deffault;
deffault.state = BGFX_STATE_DEFAULT;
deffault.program = BGFX_INVALID_HANDLE;
return sort_map::get(_shader_map, id, deffault);
}
void* load(File& file, Allocator& a)
{
const u32 size = file.size();
void* res = a.allocate(size);
file.read(res, size);
CE_ASSERT(*(u32*)res == RESOURCE_VERSION_UNIT, "Wrong version");
return res;
}
//-----------------------------------------------------------------------------
Thread::Thread(os::ThreadFunction f, LPVOID params, const char* name)
{
m_thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) f, params, 0, NULL);
CE_ASSERT(m_thread != NULL, "Unable to create thread");
m_name = name;
}
void* load(File& file, Allocator& a)
{
const u32 file_size = file.size();
void* res = a.allocate(file_size);
file.read(res, file_size);
CE_ASSERT(*(u32*)res == RESOURCE_VERSION_PHYSICS_CONFIG, "Wrong version");
return res;
}
u32 write(const void* data, u32 size)
{
CE_ASSERT(data != NULL, "Data must be != NULL");
#if CROWN_PLATFORM_POSIX
size_t bytes_written = fwrite(data, 1, size, _file);
CE_ASSERT(ferror(_file) == 0, "fwrite error");
return (u32)bytes_written;
#elif CROWN_PLATFORM_WINDOWS
DWORD bytes_written;
WriteFile(_file, data, size, &bytes_written, NULL);
CE_ASSERT(size == bytes_written
, "WriteFile: GetLastError = %d"
, GetLastError()
);
return bytes_written;
#endif
}
u32 size()
{
#if CROWN_PLATFORM_POSIX
long pos = ftell(_file);
CE_ASSERT(pos != -1, "ftell: errno = %d", errno);
int err = fseek(_file, 0, SEEK_END);
CE_ASSERT(err == 0, "fseek: errno = %d", errno);
long size = ftell(_file);
CE_ASSERT(size != -1, "ftell: errno = %d", errno);
err = fseek(_file, (long)pos, SEEK_SET);
CE_ASSERT(err == 0, "fseek: errno = %d", errno);
CE_UNUSED(err);
return (u32)size;
#elif CROWN_PLATFORM_WINDOWS
return GetFileSize(_file, NULL);
#endif
}
