• Write data to a debug console.
• All managers output warnings automatically to notify if something fails.
• Save console to a text file to review later.
• Different levels of messages (Normal, Info, Warning and Error) each with a certain color so errors can be spotted immediately.
• Invoke pop-ups to alert player / developer.
• Try catch system.
• Debug and release ASSERT system

       //Use the global Log function
       Log(_T("Message"),MESSAGE_LEVEL_NORMAL);
       

       //Use the  static LogN template method of the Debug class
       Debug::LogN(_T("Hero position x"),position.x);
        
        
        //The output will look like this
        Hero position X: 312
        

        //Use the static Pop-up method of the Debug class
        bool closeProgram = false;
        Debug::Popup(_T("Message in the pop-up"), _T("Title"), closeProgram);
        

        //Use the static Assert method of the Debug class
        bool condition = false;
        Debug::Assert(condition,_T("The condition isn't valid"),_T("Title));
        

        //Try catch with the ErrorMessage object
        try
        {
        	//Throw an ErrorMessage object by value
			throw(ErrorMessage(_T("Error message"),_T("Title"),closeProgram));
        }
        //Catch the ErrorMessage object by reference
        catch(ErrorMessage &error)
        {
        	// Run the Fire method to show the pop-up window, and potentially close the program.
            // You could save backup data before shutting down in this catch block.
            error.Fire();
        }
       

• Mouse and keyboard support.
• Check if any key/button has been pressed, is being pressed
• Check combination of keys/buttons that are pressed at the same time.
• Ability to remove input messages so they are only registered once (easy when you have UI screen rendered on top of each other).

        //Check if the key message is present
        CHIBI->GetInputManager()->CheckKeyState(KEY_MOUSE_LEFT,KEYSTATE_UP);
        

        //Remove the message from the Input Manager
        CHIBI->GetInputManager()->RemoveMessage(KEY_MOUSE_LEFT,KEYSTATE_UP);
        

• Tiles are drawn using direct-3D instancing so the number of draw calls is reduced drastically

• You can easily write scripted actions using c++11 lambdas (or functors) and add them to the Action Manager.
• Easy to use for button action, pickup actions, collision actions, ...
• Run an action at anytime from anywhere in your code with a single command.

    //Add an action to the manager, with a given tag
	CHIBI->GetActionManager()->AddAction(_T("PickupGem"),[&,this] () -> void
		{
			auto heroPtr = GetGameobjectByName(_T("Hero"));
			heroPtr->AddItem("Gem");
		}
	);
    

    //Run an action that is present in the manager
    CHIBI->GetActionManager()->RunAction(_T("PickupGem"));
        

    //Store an action that is present in the manager
    auto& m_PickAction = CHIBI->GetActionManager()->GetAction(_T("PickupGem"));
    
    //Run the action
    m_PickAction();
    
    //Remove action
    CHIBI->GetActionManager()->RemoveAction(_T("PickupGem"));
        

• Collision detection and handling in only 5 lines of code!
• Add objects to the collision manager and give them a tag (‘Hero’, ‘Mob’, ‘Pickup’, ...).
• Let objects check for collision with objects with a given tag (‘Hero’ checks for collision with ‘Pickup’).
• Script or code the OnHit event using c++11 lambdas.
• You can also manually check for collisions with objects that are added to the manager.
• You can also use Ray casting on either all objects in the scene, all objects with a certain tag or just a single object.

     //Create the hit region
	 auto hitRegionPtr = GetScene()->GetCollisionManager()->CreateHitRegionForObject(this,_T("Pickup"));

    //Check for hero
	hitRegionPtr->AddCheckTag("Hero");

    //Ignore every hit region that doesn't have the 'Hero' tag
	hitRegionPtr->OnlyCheckTags();

    //Define hit-action
	hitRegionPtr->SetListener([&](GameObject* objectPtr, const tstring& tag)->void{COLLISION ACTION});

     //Create the hitregion
	 auto hitRegionPtr = GetScene()->GetCollisionManager()->GetHitregionByObject(this);
     
    //Get Hero hitregion
	 auto heroHitRegionPtr = GetScene()->GetCollisionManager()->GetHitregionByName(_T("Hero"));
     
    //Check collision
	if(hitRegionPtr->HitTest(heroHitRegionPtr))
    {
   		//DO SOMETHING
    }

     //Get the level hitregion
	 auto levelHitRegionPtr = GetScene()->GetCollisionManager()->GetHitregionByName(_T("Level"));
     
    //Define ray
    Vector2 startPos(0,0);
    double raySize = 100;
    UINT maxResults = 4;
	Ray ray = Ray(startPos,Vector2(0,-1),raySize,maxResults);
    
    //Cast rays on the object
    if(levelHitRegionPtr->Raycast(ray))
    {
    	RayResult& result = ray.results[0];
        //DO SOMETHING
    }

    //Define ray
    Vector2 startPos(0,0);
    double raySize = 100;
    UINT maxResults = 4;
	Ray ray = Ray(startPos,Vector2(0,-1),raySize,maxResults);
    ray.AddTag(_T("NPC"));
    ray.onlyTags = true;
    
    //Raycast on every object in the scene
    if(GetScene()->GetCollisionManager()->Raycast(ray))
    {
    	RayResult& result = ray.results[0];
        //DO SOMETHING
    }

• A XML file contains all animation sets of an entity.
• Every animation set has a name and a certain amount of key frames
• Every key frame contains data about the part of the texture that needs to be rendered, the texture that the frame is taken from (possibility to use multiple textures for 1 animation) and a length.
• Play animations with just one command.

    //Add the animation to the animation manager
	CHIBI->GetAnimationManager()->ParseAnimationFile(_T("./Resources/Animations/Hero.anim"));
    
    //Create an actor with a certain animation ('Hero' is the animation set, not the file)
    auto newActorPtr = new Actor(_T("Hero"));
    
    //Play the 'Walk' animation of the 'Hero' animation set
    newActorPtr->PlayAnimation("Walk");
          

• Textures (all file types that are supported by Direct-X)
• Fonts
• Shaders (hlsl)

        //Add the images to the Image manager by giving them a tag
		CHIBI->GetImageManager()->AddTexture(_T("PATH TO FILE"), _T("TAG"));
        
        //Retrieve images by using just the tag, no need to store the file path everywhere
		if(CHIBI->GetImageManager()->IsTexturePresent(_T("TAG")))
        {
			auto& texture = CHIBI->GetImageManager()->GetTexture(_T("TAG"));
        }
        

        //Use the CreateSprite method of the Imagemanager
		auto spritePtr = CHIBI->GetImageManager()->CreateSprite(_T("TAG")));
        
        //Add the new sprite as a child to the current object
        addChild(spritePtr);
        

• Create multiple cameras.
• Switch between cameras.
• Follow Camera: Center of an object.
• Limit camera: Make sure the camera doesn’t leave a certain rectangle If the screen is bigger than the limit rectangle, the rest will be blacked out. This allows the user to create multiple rooms in the same map, and make sure the player doesn’t see them until he’s allowed to.
• Inherit the base Camera class and create your own dynamic cameras.

• Every timer is ticked automatically and can be paused, stopped and restarted with a single command.
• Timers can be set to pause when the game is paused.
• Different kinds of timers to suit every need.
• Countdown timer: Start at a given time, and count back to 0. If the timer hit’s zero it automatically stops.
• CountdownAction timer: Same as the countdown timer, but an action is fired when the timer hits 0.
• StopWatch timer: Starts at 0 and counts up. The current time can be retrieved at any moment.

• Create a UI with ease.
• Create different UI elements and add them to the UI.
• Base HUD elements present : Text, Bitmap, Rectangles, Values (auto updating pointer values).
• Interactive UI element: Button, Text box, Scrollbar.
• Create your own HUD elements by inheriting the base HUDElement class.
• Not only for games but also for tools like Level Editors.

        //Add the HUDBackground image to the Image manager, and enable the HUD_USAGE flag
		CHIBI->GetImageManager()->AddTexture(_T("./Resources/Images/HUD.bmp"), _T("HUD")
        , IMAGE_USAGE_HUD);
        
        //Create a UI objects
        UI* hudPtr = new UI();
        
        //Add the HUD as a child to the current object (A UI object is a GameObject)
        AddChild(hudPtr);
    
    	//Create a UIBitmap object to draw the 'HUD' bitmap on the HUD
        auto hudBGPtr = new UIBitmap(_T("HUDBg"),_T("HUD"));
        hudBGPtr->Scale(2);
        
        //Add the UIBitmap element to the HUD
        hudPtr->AddElement(hudBGPtr);
        

• This has the advantage that tree structures can be created and methods can function on all objects in the scene

• Add game objects to a scene.
• Retrieve any object present in the scene from anywhere in your code. (No need to store a pointer to every object yourself)

• Have multiple scene loaded so you can switch between them with ease
• Useful for menus



        //Add scenes to the Scene Manager
        CHIBI->GetSceneManager()->AddScene(_T("MainMenuScene"),new MainMenuScene());
        CHIBI->GetSceneManager()->AddScene(_T("LevelScene"),new LevelScene());
        
        //Activate a scene
        CHIBI->GetSceneManager()->SetActiveScene(_T("MainMenuScene"));
        

• Every game object has its own scale, rotation and position in local space and global space.