Architecture of Computer Games

   1
 bool Main::iteration() {
   2
 	iterating++;
   3
 
   4
 	uint64_t ticks = OS::get_singleton()->get_ticks_usec();
   5
 	Engine::get_singleton()->_frame_ticks = ticks;
   6
 	// update elapsed ticks
   7
 	// ...
   8
 	MainFrameTime advance = main_timer_sync.advance(frame_slice, physics_fps);
   9
 
  10
 	for (int iters = 0; iters < advance.physics_steps; ++iters) {
  11
 		// ... update PhysicsServer3D		
  12
 	}
  13
 
  14
 	if (DisplayServer::get_singleton()->can_any_window_draw()) {
  15
 		// ... draw frame
  16
 	}
  17
 
  18
 	for (int i = 0; i < ScriptServer::get_language_count(); i++) {
  19
 		// ... update scene for each scripting language
  20
 		ScriptServer::get_language(i)->frame();
  21
 	}
  22
 
  23
 	AudioServer::get_singleton()->update();
  24
 	frames++;
  25
 	return exit || auto_quit;
  26
 }

   1
 void* AllocatorReserve(AllocatorBlock* allocator) {
   2
     if (!allocator->free_) {
   3
         // Free nodes have been exhausted. Allocate a new larger block
   4
         unsigned newCapacity = (allocator->capacity_ + 1) >> 1;
   5
         AllocatorReserveBlock(allocator, allocator->nodeSize_, newCapacity);
   6
         allocator->capacity_ += newCapacity;
   7
     }
   8
  
   9
     // We should have new free node(s) chained
  10
     AllocatorNode* freeNode = allocator->free_;
  11
     void* ptr = (reinterpret_cast<unsigned char*>(freeNode)) + sizeof(AllocatorNode);
  12
     allocator->free_ = freeNode->next_;
  13
     freeNode->next_ = 0;
  14
     return ptr;
  15
 }
  16
 ============================
  17
 // create node from void* and call the constructor
  18
 
  Node* newNode = static_cast(AllocatorReserve(allocator_));
  19
 new(newNode) Node();
  20
 // ... do some stuff 
  21
 // delete node
  22
 (newNode)->~Node();
  23
 AllocatorFree(allocator_, newNode);

   1
 PoolAllocator::ID PoolAllocator::alloc(int p_size) {
   2
 	int size_to_alloc = aligned(p_size);
   3
 
   4
 	EntryIndicesPos new_entry_indices_pos;
   5
 
   6
 	if (!find_hole(&new_entry_indices_pos, size_to_alloc)) {
   7
 		/* No hole could be found, try compacting mem */
   8
 		compact();
   9
 		/* Then search again */
  10
 		if (!find_hole(&new_entry_indices_pos, size_to_alloc)) {
  11
 			ERR_FAIL_V_MSG(POOL_ALLOCATOR_INVALID_ID, "Memory can't be compacted further.");
  12
 		}
  13
 	}
  14
 	EntryArrayPos new_entry_array_pos;
  15
 	bool found_free_entry = get_free_entry(&new_entry_array_pos);
  16
 
  17
 	if (!found_free_entry) {
  18
 		ERR_FAIL_V_MSG(POOL_ALLOCATOR_INVALID_ID, "No free entry found in PoolAllocator.");
  19
 	}
  20
     // ... move all entry indices up and allocate the entry
  21
     // ...
  22
 	return retval;
  23
 }