Irrlicht Engine

https://github.com/zaki/irrlicht
Admin
Irrlicht Engine is an open-source 3D graphics engine for creating real-time 3D applications and...
Tokens:227,155
Snippets:2,584
Trust Score:7.5
Update:6 months ago
Show doc for...
Tokens:
Raw
### Configure Example Binaries

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/zlib/CMakeLists.txt

Builds example and minigzip executables, including 64-bit variants if supported.

```cmake
add_executable(example test/example.c)
target_link_libraries(example zlib)
add_test(example example)

add_executable(minigzip test/minigzip.c)
target_link_libraries(minigzip zlib)

if(HAVE_OFF64_T)
    add_executable(example64 test/example.c)
    target_link_libraries(example64 zlib)
    set_target_properties(example64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
    add_test(example64 example64)

    add_executable(minigzip64 test/minigzip.c)
    target_link_libraries(minigzip64 zlib)
    set_target_properties(minigzip64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
endif()
```

--------------------------------

### Install Software via Makefile

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/jpeglib/install.txt

Use standard make targets to install binaries, man pages, or the library files.

```bash
make install
```

```bash
make -n install
```

```bash
make install-lib
```

--------------------------------

### Compile Irrlicht Examples with MinGW

Source: https://github.com/zaki/irrlicht/blob/master/bin/Win32-gcc/readme.txt

Run this command within an example directory to build the specific example.

```bash
make all_win32
```

--------------------------------

### Define Installation Rules

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/zlib/CMakeLists.txt

Specifies installation paths for libraries, headers, man pages, and pkg-config files.

```cmake
if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
    install(TARGETS zlib zlibstatic
        RUNTIME DESTINATION "${INSTALL_BIN_DIR}"
        ARCHIVE DESTINATION "${INSTALL_LIB_DIR}"
        LIBRARY DESTINATION "${INSTALL_LIB_DIR}" )
endif()
if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
    install(FILES ${ZLIB_PUBLIC_HDRS} DESTINATION "${INSTALL_INC_DIR}")
endif()
if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
    install(FILES zlib.3 DESTINATION "${INSTALL_MAN_DIR}/man3")
endif()
if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
    install(FILES ${ZLIB_PC} DESTINATION "${INSTALL_PKGCONFIG_DIR}")
endif()
```

--------------------------------

### Build and Install on Unix

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/jpeglib/install.txt

Standard sequence of commands for compiling and installing the software on Unix-like systems.

```bash
./configure
make
make test
```

```bash
make install
```

```bash
make -n install
```

--------------------------------

### Irrlicht Application Setup with Custom Shader

Source: https://context7.com/zaki/irrlicht/llms.txt

Initializes the Irrlicht device, creates a scene manager, and sets up a custom shader material using GLSL shaders and a callback. It then adds a mesh node with the custom material and starts the rendering loop.

```cpp
int main()
{
    IrrlichtDevice* device = createDevice(video::EDT_OPENGL,
        core::dimension2d<u32>(800, 600));

    video::IVideoDriver* driver = device->getVideoDriver();
    scene::ISceneManager* smgr = device->getSceneManager();
    video::IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices();

    ShaderCallback* callback = new ShaderCallback();

    // GLSL shader source (for OpenGL)
    const char* vertexShader = R"(
        uniform mat4 mWorldViewProj;
        uniform mat4 mWorld;
        uniform float fTime;

        varying vec3 vNormal;
        varying vec2 vTexCoord;

        void main()
        {
            vec4 pos = gl_Vertex;
            pos.y += sin(pos.x * 0.1 + fTime) * 5.0;  // Wave effect

            gl_Position = mWorldViewProj * pos;
            vNormal = normalize((mWorld * vec4(gl_Normal, 0.0)).xyz);
            vTexCoord = gl_MultiTexCoord0.xy;
        }
    )";

    const char* pixelShader = R"(
        uniform sampler2D myTexture;

        varying vec3 vNormal;
        varying vec2 vTexCoord;

        void main()
        {
            vec3 lightDir = normalize(vec3(1.0, 1.0, -1.0));
            float diffuse = max(dot(vNormal, lightDir), 0.2);

            vec4 texColor = texture2D(myTexture, vTexCoord);
            gl_FragColor = texColor * diffuse;
        }
    )";

    // Create shader material
    s32 shaderMaterial = gpu->addHighLevelShaderMaterial(
        vertexShader, "main", video::EVST_VS_1_1,   // Vertex shader
        pixelShader, "main", video::EPST_PS_1_1,    // Pixel shader
        callback,                                     // Callback
        video::EMT_SOLID,                            // Base material
        0);                                          // User data

    callback->drop();

    // Create test mesh with custom shader
    scene::IMeshSceneNode* node = smgr->addMeshSceneNode(
        smgr->getMesh("mesh.obj")->getMesh(0));
    node->setMaterialType((video::E_MATERIAL_TYPE)shaderMaterial);
    node->setMaterialTexture(0, driver->getTexture("texture.jpg"));
    node->setMaterialFlag(video::EMF_LIGHTING, false);

    smgr->addCameraSceneNode(0, core::vector3df(0, 50, -100), core::vector3df(0, 0, 0));

    while (device->run())
    {
        driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH,
                          video::SColor(255, 50, 50, 80));
        smgr->drawAll();
        driver->endScene();
    }

    device->drop();
    return 0;
}

```

--------------------------------

### Example Calls for png_set_alpha_mode

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/libpng/libpng-manual.txt

Specific implementation examples for various display environments and processing needs.

```c
png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
```

```c
png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
```

```c
png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);
```

```c
png_set_expand_16(pp);
png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB);
```

```c
png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB);
```

--------------------------------

### Install Doxygen via Aptitude

Source: https://github.com/zaki/irrlicht/blob/master/scripts/packages/OSX/readme.txt

Install the Doxygen documentation generator if using Aptitude on macOS.

```bash
sudo apt-get install doxygen
```

--------------------------------

### Configure libpng Installation via CMake

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/libpng/CMakeLists.txt

Defines installation rules for libraries, headers, executables, and documentation based on project configuration flags.

```cmake
if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
  install(TARGETS ${PNG_LIB_TARGETS}
      ${PNG_EXPORT_RULE}
      RUNTIME DESTINATION bin
      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
      FRAMEWORK DESTINATION ${CMAKE_INSTALL_LIBDIR})

  if(PNG_SHARED)
    # Create a symlink for libpng.dll.a => libpng16.dll.a on Cygwin
    if(CYGWIN OR MINGW)
       get_target_property(BUILD_TARGET_LOCATION png LOCATION_${CMAKE_BUILD_TYPE})
       CREATE_SYMLINK(${BUILD_TARGET_LOCATION} libpng${CMAKE_IMPORT_LIBRARY_SUFFIX})
       install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_IMPORT_LIBRARY_SUFFIX}
         DESTINATION ${CMAKE_INSTALL_LIBDIR})
    endif(CYGWIN OR MINGW)

    if(NOT WIN32)
      get_target_property(BUILD_TARGET_LOCATION png LOCATION_${CMAKE_BUILD_TYPE})
      CREATE_SYMLINK(${BUILD_TARGET_LOCATION} libpng${CMAKE_SHARED_LIBRARY_SUFFIX})
      install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_SHARED_LIBRARY_SUFFIX}
         DESTINATION ${CMAKE_INSTALL_LIBDIR})
    endif(NOT WIN32)
  endif(PNG_SHARED)

  if(PNG_STATIC)
    if(NOT WIN32 OR CYGWIN OR MINGW)
      get_target_property(BUILD_TARGET_LOCATION png_static LOCATION_${CMAKE_BUILD_TYPE})
      CREATE_SYMLINK(${BUILD_TARGET_LOCATION} libpng${CMAKE_STATIC_LIBRARY_SUFFIX})
      install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_STATIC_LIBRARY_SUFFIX}
         DESTINATION ${CMAKE_INSTALL_LIBDIR})
    endif(NOT WIN32 OR CYGWIN OR MINGW)
 endif()
endif()

if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
  install(FILES ${libpng_public_hdrs}   DESTINATION include)
  install(FILES ${libpng_public_hdrs}   DESTINATION include/${PNGLIB_NAME})
endif()
if(NOT SKIP_INSTALL_EXECUTABLES AND NOT SKIP_INSTALL_ALL )
  if(NOT WIN32 OR CYGWIN OR MINGW)
    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config DESTINATION bin)
    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
            DESTINATION bin)
  endif(NOT WIN32 OR CYGWIN OR MINGW)
endif()

if(NOT SKIP_INSTALL_PROGRAMS AND NOT SKIP_INSTALL_ALL )
  install(TARGETS ${PNG_BIN_TARGETS}
      RUNTIME DESTINATION bin)
endif()

if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
  # Install man pages
  if(NOT PNG_MAN_DIR)
    set(PNG_MAN_DIR "share/man")
  endif()
  install(FILES libpng.3 libpngpf.3      DESTINATION ${PNG_MAN_DIR}/man3)
  install(FILES png.5                    DESTINATION ${PNG_MAN_DIR}/man5)
  # Install pkg-config files
  if(NOT WIN32 OR CYGWIN OR MINGW)
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng.pc
            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config
            DESTINATION bin)
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}.pc
            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
            DESTINATION bin)
  endif(NOT WIN32 OR CYGWIN OR MINGW)
endif()

# On versions of CMake that support it, create an export file CMake
# users can include() to import our targets
if(PNG_EXPORT_RULE AND NOT SKIP_INSTALL_EXPORT AND NOT SKIP_INSTALL_ALL )
  install(EXPORT libpng DESTINATION lib/libpng FILE lib${PNG_LIB_NAME}.cmake)
endif()
```

--------------------------------

### Configure Build Options

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/jpeglib/install.txt

Examples of passing flags to the configure script to customize library types, compilers, and optimization levels.

```bash
./configure --disable-shared
```

```bash
./configure --disable-static
```

```bash
./configure CC='cc'
```

```bash
./configure CC='cc -Aa'
```

```bash
./configure CFLAGS='-O2'
```

--------------------------------

### Get PNG Pass Start Column

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/libpng/libpng-manual.txt

Macro to retrieve the starting column in the output image for the first pixel of a given pass in an interlaced PNG. This is part of the information needed to de-interlace the image manually.

```c
png_uint_32 x = PNG_PASS_START_COL(pass);
```

--------------------------------

### Initialize Main Function

Source: https://github.com/zaki/irrlicht/blob/master/examples/01.HelloWorld/tutorial.html

Define the entry point for the application.

```cpp
int main()
{
```

--------------------------------

### Add start parameter to irrstring::findLast

Source: https://github.com/zaki/irrlicht/blob/master/changes.txt

The findLast method in irrstring now accepts a 'start' parameter to specify the starting position for the search.

```cpp
irrstring: added param start to findLast(T c,  s32 start = -1 )
```

--------------------------------

### Initialize PNG I/O

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/libpng/libpng-manual.txt

Sets up the input I/O for libpng using a C FILE pointer. Ensure the file is opened in binary mode.

```c
png_init_io(png_ptr, fp);
```

--------------------------------

### Set Up Camera, Cursor, and Test Cube

Source: https://github.com/zaki/irrlicht/blob/master/examples/13.RenderToTexture/tutorial.html

Configures the scene by adding an FPS camera, disabling the mouse cursor, and creating a rotating test cube with lighting disabled.

```cpp
	// add fps camera
	scene::ICameraSceneNode* fpsCamera = smgr->addCameraSceneNodeFPS();
	fpsCamera->setPosition(core::vector3df(-50,50,-150));

	// disable mouse cursor
	device->getCursorControl()->setVisible(false);

	// create test cube
	scene::ISceneNode* test = smgr->addCubeSceneNode(60);

	// let the cube rotate and set some light settings
	scene::ISceneNodeAnimator* anim = smgr->createRotationAnimator(
		core::vector3df(0.3f, 0.3f,0));

	test->setPosition(core::vector3df(-100,0,-100));
	test->setMaterialFlag(video::EMF_LIGHTING, false); // disable dynamic lighting
	test->addAnimator(anim);
	anim->drop();

	// set window caption
	device->setWindowCaption(L"Irrlicht Engine - Render to Texture and Specular Highlights example");
```

--------------------------------

### Initialize Device and Scene Manager

Source: https://github.com/zaki/irrlicht/blob/master/examples/04.Movement/tutorial.html

Setup the main application loop and initialize the Irrlicht device with the custom event receiver.

```cpp
int main()  
{  
   MyEventReceiver receiver;
   
  device = createDevice(video::EDT_OPENGL, core::dimension2d<s32>(640, 480),
       16, false, false, false, &receiver);

   video::IVideoDriver* driver = device->getVideoDriver();
   scene::ISceneManager* smgr = device->getSceneManager();
```

--------------------------------

### Initialize Scene and Drawing Loop

Source: https://github.com/zaki/irrlicht/blob/master/examples/09.Meshviewer/tutorial.html

Sets up the scene by adding a skybox and a Maya camera. It then enters the main application loop, handling device events, rendering the scene, and updating the FPS display.

```cpp
// show about message box and load default model  
showAboutText();  
loadModel(StartUpModelFile.c_str());  
// add skybox   
SkyBox = smgr->addSkyBoxSceneNode(  
	driver->getTexture("../../media/irrlicht2_up.bmp"),  
	driver->getTexture("../../media/irrlicht2_dn.bmp"),  
	driver->getTexture("../../media/irrlicht2_lf.bmp"),  
	driver->getTexture("../../media/irrlicht2_rt.bmp"),  
	driver->getTexture("../../media/irrlicht2_ft.bmp"),  
	driver->getTexture("../../media/irrlicht2_bk.bmp"));  
  
// add a camera scene node   
smgr->addCameraSceneNodeMaya();  
  
// draw everything  
while(Device->run() && driver)  
	if (Device->isWindowActive())  
	{
			driver->beginScene(true, true, video::SColor(150,50,50,50));  
			smgr->drawAll();  
		  
			env->drawAll();  
		  
			driver->endScene();  
  
			core::stringw str = L"FPS: ";  
			str += driver->getFPS();  
			fpstext->setText(str.c_str());  
	}
Device->drop();
return 0;
}
```

--------------------------------

### Initialize Particle System with Emitters and Affectors

Source: https://context7.com/zaki/irrlicht/llms.txt

Demonstrates setting up a particle system with a box emitter and various affectors like fade, gravity, and scale to control particle behavior.

```cpp
#include <irrlicht.h>
using namespace irr;

int main()
{
    IrrlichtDevice* device = createDevice(video::EDT_OPENGL,
        core::dimension2d<u32>(800, 600));

    video::IVideoDriver* driver = device->getVideoDriver();
    scene::ISceneManager* smgr = device->getSceneManager();

    // Create particle system
    scene::IParticleSystemSceneNode* ps = smgr->addParticleSystemSceneNode(false);
    ps->setPosition(core::vector3df(0, 0, 40));

    // Create box emitter (particles spawn in a box volume)
    scene::IParticleBoxEmitter* emitter = ps->createBoxEmitter(
        core::aabbox3d<f32>(-5, 0, -5, 5, 1, 5),    // Emitter box
        core::vector3df(0.0f, 0.06f, 0.0f),          // Direction + speed
        80, 100,                                      // Min/max particles per second
        video::SColor(0, 255, 255, 255),             // Min color
        video::SColor(0, 255, 255, 255),             // Max color
        800, 2000,                                    // Min/max lifetime (ms)
        0,                                            // Max angle deviation
        core::dimension2df(5.0f, 5.0f),              // Min size
        core::dimension2df(10.0f, 10.0f)             // Max size
    );

    ps->setEmitter(emitter);
    emitter->drop();

    // Alternative emitters:
    // createPointEmitter() - particles from single point
    // createSphereEmitter() - particles from sphere surface
    // createRingEmitter() - particles from ring
    // createCylinderEmitter() - particles from cylinder

    // Add fade out affector (particles fade over time)
    scene::IParticleAffector* fadeAffector = ps->createFadeOutParticleAffector(
        video::SColor(0, 0, 0, 0),  // Target color
        1500);                       // Time to fade (ms)
    ps->addAffector(fadeAffector);
    fadeAffector->drop();

    // Add gravity affector
    scene::IParticleAffector* gravityAffector = ps->createGravityAffector(
        core::vector3df(0.0f, -0.03f, 0.0f),  // Gravity direction
        1000);                                  // Time to affect
    ps->addAffector(gravityAffector);
    gravityAffector->drop();

    // Add scale affector (particles grow/shrink)
    scene::IParticleAffector* scaleAffector = ps->createScaleParticleAffector(
        core::dimension2df(20.0f, 20.0f));  // Target size
    ps->addAffector(scaleAffector);
    scaleAffector->drop();

    // Set particle material
    ps->setMaterialFlag(video::EMF_LIGHTING, false);
    ps->setMaterialFlag(video::EMF_ZWRITE_ENABLE, false);
    ps->setMaterialTexture(0, driver->getTexture("fire.bmp"));
    ps->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);

    // Add camera
    smgr->addCameraSceneNodeFPS(0, 100.0f, 0.3f);

    while (device->run())
    {
        driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH,
                          video::SColor(255, 0, 0, 0));
        smgr->drawAll();
        driver->endScene();
    }

    device->drop();
    return 0;
}
```

--------------------------------

### Set Installation Library Directory

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/libpng/CMakeLists.txt

Sets the CMAKE_INSTALL_LIBDIR to 'lib' if it is not already defined. This ensures consistent library installation paths.

```cmake
if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
  set(CMAKE_INSTALL_LIBDIR lib)
endif(NOT DEFINED CMAKE_INSTALL_LIBDIR)
```

--------------------------------

### Initialize Device and Driver Selection

Source: https://github.com/zaki/irrlicht/blob/master/examples/11.PerPixelLighting/tutorial.html

Main function entry point to initialize the Irrlicht device and prompt the user for a video driver.

```cpp
int main()
{
	// let user select driver type

	video::E_DRIVER_TYPE driverType = video::EDT_DIRECT3D9;
  
	printf("Please select the driver you want for this example:\n"\
		" (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\
		" (d) Software Renderer\n (e) Apfelbaum Software Renderer\n"\
		" (f) NullDevice\n (otherKey) exit\n\n");  
	char i;
	std::cin >> i;

	switch(i)
	{  
		case 'a': driverType = video::EDT_DIRECT3D9;break;  
		case 'b': driverType = video::EDT_DIRECT3D8;break;
```

--------------------------------

### Compile Irrlicht as a Shared Library on Linux

Source: https://github.com/zaki/irrlicht/blob/master/changes.txt

To compile Irrlicht as a shared library on Linux, navigate to the source folder and run 'make sharedlib'. This creates a libIrrlicht.so.0.11.0 file. To install it, run 'make install'.

```bash
make sharedlib
make install
```

--------------------------------

### Initialize Irrlicht Device and Driver

Source: https://github.com/zaki/irrlicht/blob/master/examples/10.Shaders/tutorial.html

Sets up the video driver based on user input and initializes the Irrlicht device.

```cpp
		case 'c': driverType = video::EDT_OPENGL;   break;  
		case 'd': driverType = video::EDT_SOFTWARE; break;  
		case 'e': driverType = video::EDT_BURNINGSVIDEO;break;  
		case 'f': driverType = video::EDT_NULL;     break;  
		default: return 1;  
	}  
  
  // ask the user if we should use high level shaders for this example  
  if (driverType == video::EDT_DIRECT3D9 ||  
 		 driverType == video::EDT_OPENGL)
  {  
      printf("Please press 'y' if you want to use high level shaders.\n");  
      std::cin >> i;  
      if (i == 'y')  
         UseHighLevelShaders = true;  
	}  
  
	// create device  
  
	device = createDevice(driverType, core::dimension2d<s32>(640, 480));  
  
	if (device == 0)  
	{  
		printf("\nWas not able to create driver.\n"\  
			"Please restart and select another driver.\n");  
		getch();  
		return 1;  
	}  
  
	video::IVideoDriver* driver = device->getVideoDriver();  
	scene::ISceneManager* smgr = device->getSceneManager();  
	gui::IGUIEnvironment* gui = device->getGUIEnvironment();
```

--------------------------------

### Create and Populate Menu

Source: https://github.com/zaki/irrlicht/blob/master/examples/09.Meshviewer/tutorial.html

Demonstrates creating a main menu with submenus and menu items. Submenus are accessed by index after creating the parent menu item.

```cpp
// set a nicer font  
IGUISkin* skin = env->getSkin();  
IGUIFont* font = env->getFont("../../media/fonthaettenschweiler.bmp");  
if (font)  
	skin->setFont(font);  
  
// create menu  
gui::IGUIContextMenu* menu = env->addMenu();  
menu->addItem(L"File", -1, true, true);  
menu->addItem(L"View", -1, true, true);  
menu->addItem(L"Help", -1, true, true);  
  
gui::IGUIContextMenu* submenu;  
submenu = menu->getSubMenu(0);  
submenu->addItem(L"Open Model File...", 100);  
submenu->addSeparator();  
submenu->addItem(L"Quit", 200);  
  
submenu = menu->getSubMenu(1);  
submenu->addItem(L"toggle sky box visibility", 300);  
submenu->addItem(L"toggle model debug information", 400);  
submenu->addItem(L"model material", -1, true, true );  
  
submenu = submenu->getSubMenu(2);  
submenu->addItem(L"Solid", 610);  
submenu->addItem(L"Transparent", 620);  
submenu->addItem(L"Reflection", 630);  
  
submenu = menu->getSubMenu(2);  
submenu->addItem(L"About", 500);
```

--------------------------------

### Get Device Type

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Returns the type of the Irrlicht device.

```cpp
virtual E_DEVICE_TYPE getType() const = 0;
```

--------------------------------

### Get File Directory

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Extracts the directory part of a filename.

```cpp
virtual path getFileDir(const path& filename) const =0;
```

--------------------------------

### Initialize Scene Elements for Picking

Source: https://github.com/zaki/irrlicht/blob/master/examples/07.Collision/tutorial.html

Configures the cursor, adds a billboard for intersection visualization, and spawns animated faerie meshes.

```cpp
_// disable mouse cursor_

	device->getCursorControl()->setVisible(false);

	_// add billboard_

	scene::IBillboardSceneNode * bill = smgr->addBillboardSceneNode();
	bill->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR );
	bill->setMaterialTexture(0, driver->getTexture(  
         "../../media/particle.bmp"));
	bill->setMaterialFlag(video::EMF_LIGHTING, false);
	bill->setSize(core::dimension2d<f32>(20.0f, 20.0f));

	_// add 3 animated faeries._

	video::SMaterial material;
	material.Texture1 = driver->getTexture(         "../../media/faerie2.bmp");
	material.Lighting = true;

	scene::IAnimatedMeshSceneNode* node = 0;
	scene::IAnimatedMesh* faerie = smgr->getMesh(  
        "../../media/faerie.md2");

	if (faerie)
	{
		node = smgr->addAnimatedMeshSceneNode(faerie);
		node->setPosition(core::vector3df(-70,0,-90));
		node->setMD2Animation(scene::EMAT_RUN);
		node->getMaterial(0) = material;

		node = smgr->addAnimatedMeshSceneNode(faerie);
		node->setPosition(core::vector3df(-70,0,-30));
		node->setMD2Animation(scene::EMAT_SALUTE);
		node->getMaterial(0) = material;

		node = smgr->addAnimatedMeshSceneNode(faerie);
		node->setPosition(core::vector3df(-70,0,-60));
		node->setMD2Animation(scene::EMAT_JUMP);
		node->getMaterial(0) = material;
	}

	material.Texture1 = 0;
	material.Lighting = false;

	_// Add a light_

	smgr->addLightSceneNode(0, core::vector3df(-60,100,400),
		video::SColorf(1.0f,1.0f,1.0f,1.0f),
		600.0f);
```

--------------------------------

### Get Absolute Path

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Converts a filename to its absolute path.

```cpp
virtual path getAbsolutePath(const path& filename) const =0;
```

--------------------------------

### Get Working Directory

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Retrieves the current working directory.

```cpp
virtual const path& getWorkingDirectory() =0;
```

--------------------------------

### Main Rendering Loop

Source: https://github.com/zaki/irrlicht/blob/master/examples/08.SpecialFX/tutorial.html

Initializes the camera and executes the main application loop to draw the scene and update the window caption.

```cpp
scene::ICameraSceneNode* camera = smgr->addCameraSceneNodeFPS();
	camera->setPosition(core::vector3df(-50,50,-150));


	int lastFPS = -1;

	while(device->run())
	{
		driver->beginScene(true, true, 0);

		smgr->drawAll();

		driver->endScene();

		int fps = driver->getFPS();

		if (lastFPS != fps)
		{
		  core::stringw str = L"Irrlicht Engine - SpecialFX example [";  
		  str += driver->getName();  
		  str += "] FPS:";  
		  str += fps;  
  
		  device->setWindowCaption(str.c_str());  
		  lastFPS = fps;  
		}
	}

	device->drop();
	
	return 0;
}
```

--------------------------------

### GET /png/sCAL

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/libpng/libpng-manual.txt

Retrieves the sCAL (Physical Scale) chunk data.

```APIDOC
## GET /png/sCAL

### Description
Retrieves physical scale units, width, and height. The sCAL_s variant returns width and height as strings.

### Parameters
#### Request Body
- **png_ptr** (pointer) - Required - The PNG structure pointer
- **info_ptr** (pointer) - Required - The info structure pointer
- **unit** (pointer) - Required - Pointer to store unit integer
- **width** (pointer) - Required - Pointer to store width
- **height** (pointer) - Required - Pointer to store height
```

--------------------------------

### Initialize Irrlicht Device and Select Driver

Source: https://github.com/zaki/irrlicht/blob/master/examples/13.RenderToTexture/tutorial.html

Sets up the Irrlicht device, allowing the user to select a rendering driver. Includes necessary headers and namespace usage.

```cpp
#include <irrlicht.h>
#include <iostream>

using namespace irr;

#pragma comment(lib, "Irrlicht.lib")

int main()
{
	// let user select driver type

	video::E_DRIVER_TYPE driverType = video::EDT_DIRECT3D9;

	printf("Please select the driver you want for this example:\n"\
		" (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\
		" (d) Software Renderer\n (e) Apfelbaum Software Renderer\n"\
		" (f) NullDevice\n (otherKey) exit\n\n");

	char i;
	std::cin >> i;

	switch(i)  
	{
		case 'a': driverType = video::EDT_DIRECT3D9;break;  
		case 'b': driverType = video::EDT_DIRECT3D8;break;  
		case 'c': driverType = video::EDT_OPENGL;   break;  
		case 'd': driverType = video::EDT_SOFTWARE; break;  
		case 'e': driverType = video::EDT_BURNINGSVIDEO;break;  
		case 'f': driverType = video::EDT_NULL;     break;  
		default: return 1;
	}	

	// create device and exit if creation failed

	IrrlichtDevice *device =
		createDevice(driverType, core::dimension2d(640, 480),
		16, false, false);

	if (device == 0)
		return 1; // could not create selected driver.

	video::IVideoDriver* driver = device->getVideoDriver();
	scene::ISceneManager* smgr = device->getSceneManager();
	gui::IGUIEnvironment* env = device->getGUIEnvironment();
```

--------------------------------

### Get Gamma Ramp

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Retrieves the current gamma correction values.

```cpp
virtual bool getGammaRamp(f32 &red, f32 &green, f32 &blue,
			f32 &brightness, f32 &contrast) = 0;
```

--------------------------------

### Get Pixel Color

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Retrieves the color of a pixel at specified coordinates.

```cpp
virtual SColor getPixel(u32 x, u32 y) const = 0;
```

--------------------------------

### Create and Open File

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Creates a new file for reading. Uses io::path for filenames.

```cpp
virtual IReadFile* createAndOpenFile(const path& filename) =0;
```

--------------------------------

### Get Particle Emitter Type

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Returns the type of the particle emitter.

```cpp
virtual E_PARTICLE_EMITTER_TYPE getType() const = 0;
```

--------------------------------

### Get Particle Affector Type

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Returns the type of the particle affector.

```cpp
virtual E_PARTICLE_AFFECTOR_TYPE getType() const = 0;
```

--------------------------------

### Get Mesh Count

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Retrieves the total number of meshes available.

```cpp
virtual u32 getMeshCount() const = 0;
```

--------------------------------

### Main Function and Driver Selection

Source: https://github.com/zaki/irrlicht/blob/master/examples/05.UserInterface/tutorial.html

Initializes the application and prompts the user to select a video driver.

```cpp
int main()
{
  // ask user for driver
  video::E_DRIVER_TYPE driverType;


  printf("Please select the driver you want for this example:\n"\
    " (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\
    " (d) Software Renderer\n (e) Apfelbaum Software Renderer\n"\
    " (f) NullDevice\n (otherKey) exit\n\n");  
  
  char i;  
  std::cin >> i;  
  switch(i)  
  {  
    case 'a': driverType = video::EDT_DIRECT3D9;break;  
    case 'b': driverType = video::EDT_DIRECT3D8;break;  
    case 'c': driverType = video::EDT_OPENGL;   break;  
    case 'd': driverType = video::EDT_SOFTWARE; break;  
    case 'e': driverType = video::EDT_BURNINGSVIDEO;break;  
    case 'f': driverType = video::EDT_NULL;     break;  
    default: return 1;  
  }	
```

--------------------------------

### Legacy Feature Macro Compatibility

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/libpng/libpng-manual.txt

Examples of deprecated feature macros and their replacements.

```c
PNG_INCH_CONVERSIONS turns on PNG_INCH_CONVERSIONS_SUPPORTED
```

```c
PNG_SETJMP_NOT_SUPPORTED disables SETJMP
PNG_READ_TRANSFORMS_NOT_SUPPORTED disables READ_TRANSFORMS
PNG_NO_READ_COMPOSITED_NODIV disables READ_COMPOSITE_NODIV
PNG_WRITE_TRANSFORMS_NOT_SUPPORTED disables WRITE_TRANSFORMS
PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED disables READ_ANCILLARY_CHUNKS
PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED disables WRITE_ANCILLARY_CHUNKS
```

--------------------------------

### Configure Scene and Camera

Source: https://github.com/zaki/irrlicht/blob/master/examples/12.TerrainRendering/tutorial.html

Sets up the scene environment, including the engine logo, help text, and a first-person camera.

```cpp
video::IVideoDriver* driver = device->getVideoDriver();
scene::ISceneManager* smgr = device->getSceneManager();
gui::IGUIEnvironment* env = device->getGUIEnvironment();

driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, true);

// add irrlicht logo
env->addImage(driver->getTexture("../../media/irrlichtlogoalpha.tga"),
    core::position2d<s32>(10,10));
// add some help text
gui::IGUIStaticText* text = env->addStaticText(
	L"Press 'W' to change wireframe mode\nPress 'D' to toggle detail map",
	core::rect<s32>(10,453,200,475), true, true, 0, -1, true);
// add camera
scene::ICameraSceneNode* camera = 
    smgr->addCameraSceneNodeFPS(0,100.0f,1200.0f);
camera->setPosition(core::vector3df(1900*2,255*2,3700*2));
camera->setTarget(core::vector3df(2397*2,343*2,2700*2));
camera->setFarValue(12000.0f);

// disable mouse cursor
device->getCursorControl()->setVisible(false);
```

--------------------------------

### GET /png/pHYs

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/libpng/libpng-manual.txt

Retrieves the pHYs (Physical Pixel Dimensions) chunk data.

```APIDOC
## GET /png/pHYs

### Description
Retrieves physical resolution data including x and y pixels per unit and the unit type.

### Parameters
#### Request Body
- **png_ptr** (pointer) - Required - The PNG structure pointer
- **info_ptr** (pointer) - Required - The info structure pointer
- **res_x** (pointer) - Required - Pointer to store x resolution
- **res_y** (pointer) - Required - Pointer to store y resolution
- **unit_type** (pointer) - Required - Pointer to store unit type (PNG_RESOLUTION_UNKNOWN or PNG_RESOLUTION_METER)
```

--------------------------------

### Initialize Engine and Driver Selection

Source: https://github.com/zaki/irrlicht/blob/master/examples/10.Shaders/tutorial.html

Main entry point that prompts the user to select a video driver type.

```cpp
int main()  
{  
	// let user select driver type  
  
	video::E_DRIVER_TYPE driverType = video::EDT_DIRECTX9;  
  
	printf("Please select the driver you want for this example:\n"\
		" (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\
		" (d) Software Renderer\n (e) Apfelbaum Software Renderer\n"\
		" (f) NullDevice\n (otherKey) exit\n\n");  
  
	char i;  
	std::cin >> i;  
  
	switch(i)  
	{  
		case 'a': driverType = video::EDT_DIRECT3D9;break;  
		case 'b': driverType = video::EDT_DIRECT3D8;break;
```

--------------------------------

### Initialize Irrlicht Headers and Linker

Source: https://github.com/zaki/irrlicht/blob/master/examples/04.Movement/tutorial.html

Standard setup including necessary headers, namespace usage, and linker directives for the Irrlicht library.

```cpp
#include <stdio.h>  
#include <wchar.h>  
#include <irrlicht.h>

using namespace irr;

#pragma comment(lib, "Irrlicht.lib")
```

--------------------------------

### Get File Archive by Index

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Retrieves a file archive object by its index.

```cpp
virtual IFileArchive* getFileArchive(u32 index) =0;
```

--------------------------------

### Get Desktop Resolution

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Retrieves the current desktop resolution. This method is const.

```cpp
virtual const core::dimension2d<u32>& getDesktopResolution() const = 0;
```

--------------------------------

### Get File Name - IReadFile

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Retrieves the name of the file. This is a const method.

```cpp
virtual const c8* getFileName() const = 0;
```

--------------------------------

### Create Toolbar with Buttons and Combobox

Source: https://github.com/zaki/irrlicht/blob/master/examples/09.Meshviewer/tutorial.html

Shows how to create a toolbar and add buttons with textures, as well as a combobox with selectable filter options.

```cpp
// create toolbar  
gui::IGUIToolBar* bar = env->addToolBar();  
bar->addButton(1102, 0, driver->getTexture("../../media/open.bmp"));  
bar->addButton(1103, 0, driver->getTexture("../../media/help.bmp"));  
bar->addButton(1104, 0, driver->getTexture("../../media/tools.bmp"));  
  
// create a combobox with some senseless texts  
gui::IGUIComboBox* box = env->addComboBox(core::rect<s32>(100,5,200,25), bar);  
box->addItem(L"Bilinear");  
box->addItem(L"Trilinear");  
box->addItem(L"Anisotropic");  
box->addItem(L"Isotropic");  
box->addItem(L"Psychedelic");  
box->addItem(L"No filtering");
```

--------------------------------

### Get Mesh Filename by Index

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Retrieves the filename of a mesh using its index.

```cpp
virtual const c8* getMeshFilename(u32 index) const = 0;
```

--------------------------------

### Initialize Irrlicht Device

Source: https://github.com/zaki/irrlicht/blob/master/examples/09.Meshviewer/tutorial.html

Sets up the Irrlicht device with user-selected driver and window settings.

```cpp
int main()  
{  
 // ask user for driver
  
	video::E_DRIVER_TYPE driverType;
  
	printf("Please select the driver you want for this example:\n"\  
		" (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\  
		" (d) Software Renderer\n (e) Apfelbaum Software Renderer\n"\  
		" (f) NullDevice\n (otherKey) exit\n\n");  
  
	char key;  
	std::cin >> key;  
  
	switch(key)  
	{  
		case 'a': driverType = video::EDT_DIRECT3D9;break;  
		case 'b': driverType = video::EDT_DIRECT3D8;break;  
		case 'c': driverType = video::EDT_OPENGL;   break;  
		case 'd': driverType = video::EDT_SOFTWARE; break;  
		case 'e': driverType = video::EDT_BURNINGSVIDEO;break;  
		case 'f': driverType = video::EDT_NULL;     break;  
		default: return 1;  
	}	
  
	// create device and exit if creation failed
  
	MyEventReceiver receiver;  
	Device = createDevice(driverType, core::dimension2d<s32>(640, 480),  
		16, false, false, false, &receiver);
  
	if (Device == 0)  
		return 1;  // could not create selected driver.  
  
	Device->setResizable(true);  
	Device->setWindowCaption(L"Irrlicht Engine - Loading...");  
  
	video::IVideoDriver* driver = Device->getVideoDriver();  
	IGUIEnvironment* env = Device->getGUIEnvironment();  
	scene::ISceneManager* smgr = Device->getSceneManager();
```

--------------------------------

### Create Irrlicht Device and Main Loop

Source: https://context7.com/zaki/irrlicht/llms.txt

Initializes the Irrlicht device with specified parameters and runs the main application loop. Ensure to call `drop()` on the device when finished to release resources.

```cpp
#include <irrlicht.h>
using namespace irr;

int main()
{
    // Create device with OpenGL renderer, 800x600 window, 32-bit color
    // Parameters: driver type, window size, bits per pixel, fullscreen,
    //             stencil buffer, vsync, event receiver
    IrrlichtDevice* device = createDevice(
        video::EDT_OPENGL,           // Driver: EDT_OPENGL, EDT_DIRECT3D9, EDT_SOFTWARE, EDT_BURNINGSVIDEO
        core::dimension2d<u32>(800, 600),  // Window size
        32,                          // Bits per pixel
        false,                       // Fullscreen
        true,                        // Stencil buffer (for shadows)
        false,                       // VSync
        0                            // Event receiver (optional)
    );

    if (!device)
        return 1;  // Device creation failed

    device->setWindowCaption(L"My Irrlicht Application");

    // Get subsystem pointers
    video::IVideoDriver* driver = device->getVideoDriver();
    scene::ISceneManager* smgr = device->getSceneManager();
    gui::IGUIEnvironment* gui = device->getGUIEnvironment();

    // Main loop
    while (device->run())
    {
        driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH,
                          video::SColor(255, 100, 101, 140));
        smgr->drawAll();
        gui->drawAll();
        driver->endScene();
    }

    device->drop();  // Release device
    return 0;
}
```

--------------------------------

### Get Line Segment Length

Source: https://github.com/zaki/irrlicht/blob/master/doc/upgrade-guide.txt

Calculates and returns the length of a line segment.

```cpp
T getLength() const
```

--------------------------------

### GET /png/sPLT

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/libpng/libpng-manual.txt

Retrieves the sPLT (Suggested Palette) chunks from the PNG info structure.

```APIDOC
## GET /png/sPLT

### Description
Retrieves the number of sPLT chunks and the array of palette structures.

### Parameters
#### Request Body
- **png_ptr** (pointer) - Required - The PNG structure pointer
- **info_ptr** (pointer) - Required - The info structure pointer
- **palette_ptr** (pointer) - Required - Pointer to store the array of palette structures

### Response
#### Success Response (200)
- **num_spalettes** (integer) - Number of sPLT chunks read.
```

--------------------------------

### Main Application Loop and Driver Selection

Source: https://github.com/zaki/irrlicht/blob/master/examples/06.2DGraphics/tutorial.html

Prompts the user for a driver type and initializes the Irrlicht device.

```cpp
int main()  
{  
  // let user select driver type  
  video::E_DRIVER_TYPE driverType;  
  
  printf("Please select the driver you want for this example:\n"\
		" (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\
		" (d) Software Renderer\n (e) Apfelbaum Software Renderer\n"\
		" (f) NullDevice\n (otherKey) exit\n\n");  
  
   char i;  
   std::cin >> i;  
  
   switch(i)  
   {  
      case 'a': driverType = video::EDT_DIRECT3D9;break;  
      case 'b': driverType = video::EDT_DIRECT3D8;break;  
      case 'c': driverType = video::EDT_OPENGL;   break;  
      case 'd': driverType = video::EDT_SOFTWARE; break;  
      case 'e': driverType = video::EDT_BURNINGSVIDEO;break;  
      case 'f': driverType = video::EDT_NULL;     break;  
      default: return 0;  
   }	  
  
   // create device

  IrrlichtDevice *device = createDevice(driverType,
         core::dimension2d<s32>(512, 384));

  if (device == 0)
      return 1;
   
  device->setWindowCaption(L"Irrlicht Engine - 2D Graphics Demo");

  video::IVideoDriver* driver = device->getVideoDriver();
```

--------------------------------

### Get PNG Channels

Source: https://github.com/zaki/irrlicht/blob/master/source/Irrlicht/libpng/libpng-manual.txt

Retrieves the number of channels for the color type of the PNG image.

```c
channels = png_get_channels(png_ptr, info_ptr);
```
Tokens:
Raw