Mirrorlandia_minetest/minetest
1
0
Fork 1
mirror of https://github.com/minetest/minetest.git synced 2024-12-22 22:22:23 +01:00
Code Issues Packages Projects Releases Wiki Activity

Copy irrlichtmt to <root>/irr/

Browse Source
This commit is contained in:
import 2024-03-21 20:13:15 +01:00 committed by sfan5
parent a7908da968
commit f638482fba
349 changed files with 109124 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
irr/.editorconfig Executable file
View File

@ -0,0 +1,10 @@
root = true
[*]
charset = utf-8
[*.{cpp,h,txt,cmake,fsh,vsh}]
indent_size = 4
indent_style = tab
insert_final_newline = true
trim_trailing_whitespace = true

310
irr/.github/workflows/build.yml vendored Normal file
View File

@ -0,0 +1,310 @@
name: build
# build on c/cpp changes or workflow changes
on:
- push
- pull_request
jobs:
linux-gl:
runs-on: ubuntu-20.04
steps:
- uses: actions/checkout@v4
- name: Install deps
run: |
sudo apt-get update
sudo apt-get install g++ cmake libxi-dev libgl1-mesa-dev libpng-dev libjpeg-dev zlib1g-dev -qyy
- name: Build
run: |
cmake . -DUSE_SDL2=OFF
make VERBOSE=1 -j2
- name: Test
run: |
ctest --output-on-failure
- name: Package
run: |
make DESTDIR=$PWD/_install install
tar -c -I "gzip -9" -f irrlicht-linux.tar.gz -C ./_install/usr/local .
- uses: actions/upload-artifact@v4
with:
name: irrlicht-linux
path: ./irrlicht-linux.tar.gz
linux-gles:
# Xvfb test is broken on 20.04 for unknown reasons (not our bug)
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v4
- name: Install deps
run: |
sudo apt-get update
sudo apt-get install g++ cmake libxi-dev libgles2-mesa-dev libpng-dev libjpeg-dev zlib1g-dev xvfb -qyy
- name: Build
run: |
cmake . -DBUILD_EXAMPLES=1 -DUSE_SDL2=OFF -DENABLE_OPENGL=OFF -DENABLE_GLES2=ON
make -j2
- name: Test (headless)
run: |
cd bin/Linux
./AutomatedTest null
- name: Test (Xvfb)
run: |
cd bin/Linux
LIBGL_ALWAYS_SOFTWARE=true xvfb-run ./AutomatedTest ogles2
linux-sdl:
runs-on: ubuntu-20.04
steps:
- uses: actions/checkout@v4
- name: Install deps
run: |
sudo apt-get update
sudo apt-get install g++ cmake libsdl2-dev libpng-dev libjpeg-dev zlib1g-dev -qyy
- name: Build
run: |
cmake . -DBUILD_EXAMPLES=1 -DUSE_SDL2=ON -DCMAKE_BUILD_TYPE=Debug
make -j2
- name: Test (headless)
run: |
cd bin/Linux
./AutomatedTest null
linux-sdl-gl3:
# Xvfb test is broken on 20.04 for unknown reasons (not our bug)
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v4
- name: Install deps
run: |
sudo apt-get update
sudo apt-get install g++ cmake libsdl2-dev libpng-dev libjpeg-dev zlib1g-dev xvfb -qyy
- name: Build
run: |
cmake . -DBUILD_EXAMPLES=1 -DUSE_SDL2=ON -DENABLE_OPENGL=OFF -DENABLE_OPENGL3=ON
make -j2
- name: Test (headless)
run: |
cd bin/Linux
./AutomatedTest null
- name: Test (Xvfb)
run: |
cd bin/Linux
LIBGL_ALWAYS_SOFTWARE=true xvfb-run ./AutomatedTest opengl3
linux-sdl-gles2:
runs-on: ubuntu-20.04
steps:
- uses: actions/checkout@v4
- name: Install deps
run: |
sudo apt-get update
sudo apt-get install g++ cmake libsdl2-dev libpng-dev libjpeg-dev zlib1g-dev xvfb -qyy
- name: Build
run: |
cmake . -DBUILD_EXAMPLES=1 -DUSE_SDL2=ON -DENABLE_OPENGL=OFF -DENABLE_GLES2=ON
make -j2
- name: Test (headless)
run: |
cd bin/Linux
./AutomatedTest null
- name: Test (Xvfb)
run: |
cd bin/Linux
LIBGL_ALWAYS_SOFTWARE=true xvfb-run ./AutomatedTest ogles2
mingw:
name: "MinGW ${{matrix.config.variant}}${{matrix.config.extras}}"
runs-on: ubuntu-22.04
strategy:
fail-fast: false
matrix:
config:
- {variant: win32, arch: i686}
- {variant: win64, arch: x86_64}
- {variant: win32, arch: i686, extras: "-sdl"}
- {variant: win64, arch: x86_64, extras: "-sdl"}
steps:
- uses: actions/checkout@v4
- name: Install compiler
run: |
sudo apt-get update && sudo apt-get install cmake -qyy
./scripts/ci-get-mingw.sh
- name: Build
run: |
./scripts/ci-build-mingw.sh package
env:
CC: ${{matrix.config.arch}}-w64-mingw32-clang
CXX: ${{matrix.config.arch}}-w64-mingw32-clang++
extras: ${{matrix.config.extras}}
- uses: actions/upload-artifact@v4
with:
name: irrlicht-${{matrix.config.variant}}${{matrix.config.extras}}
path: ./irrlicht-${{matrix.config.variant}}${{matrix.config.extras}}.zip
macos:
runs-on: macos-latest
steps:
- uses: actions/checkout@v4
- name: Install deps
run: |
brew update --auto-update
brew install cmake libpng jpeg
env:
HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
HOMEBREW_NO_INSTALL_CLEANUP: 1
- name: Build
run: |
cmake . -DCMAKE_FIND_FRAMEWORK=LAST -DBUILD_EXAMPLES=1
make -j3
- name: Test (headless)
run: |
./bin/OSX/AutomatedTest null
macos-sdl:
runs-on: macos-latest
steps:
- uses: actions/checkout@v4
- name: Install deps
run: |
brew update --auto-update
brew install cmake libpng jpeg sdl2
env:
HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
HOMEBREW_NO_INSTALL_CLEANUP: 1
- name: Build
run: |
cmake . -DCMAKE_FIND_FRAMEWORK=LAST -DBUILD_EXAMPLES=1 -DUSE_SDL2=1
make -j3
msvc:
name: VS 2019 ${{ matrix.config.arch }} ${{ matrix.sdl.label }}
runs-on: windows-2019
env:
VCPKG_VERSION: 8eb57355a4ffb410a2e94c07b4dca2dffbee8e50
# 2023.10.19
vcpkg_packages: zlib libpng libjpeg-turbo
strategy:
fail-fast: false
matrix:
config:
-
arch: x86
generator: "-G'Visual Studio 16 2019' -A Win32"
vcpkg_triplet: x86-windows
-
arch: x64
generator: "-G'Visual Studio 16 2019' -A x64"
vcpkg_triplet: x64-windows
sdl:
-
use: FALSE
label: '(no SDL)'
vcpkg_packages: opengl-registry
-
use: TRUE
label: '(with SDL)'
vcpkg_packages: sdl2
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Restore from cache and run vcpkg
uses: lukka/run-vcpkg@v7
with:
vcpkgArguments: ${{env.vcpkg_packages}} ${{matrix.sdl.vcpkg_packages}}
vcpkgDirectory: '${{ github.workspace }}\vcpkg'
appendedCacheKey: ${{ matrix.config.vcpkg_triplet }}
vcpkgGitCommitId: ${{ env.VCPKG_VERSION }}
vcpkgTriplet: ${{ matrix.config.vcpkg_triplet }}
- name: CMake
run: |
cmake ${{matrix.config.generator}} `
-DUSE_SDL2=${{matrix.sdl.use}} `
-DCMAKE_TOOLCHAIN_FILE="${{ github.workspace }}\vcpkg\scripts\buildsystems\vcpkg.cmake" `
-DCMAKE_BUILD_TYPE=Release .
- name: Build
run: cmake --build . --config Release
- name: Create artifact folder
run: |
mkdir artifact/
mkdir artifact/lib/
- name: Move dlls into artifact folder
run: move bin\Win32-VisualStudio\Release\* artifact\lib\
- name: Move includes into artifact folder
run: move include artifact/
- name: Upload Artifact
uses: actions/upload-artifact@v4
with:
name: msvc-${{ matrix.config.arch }}-${{matrix.sdl.use}}
path: artifact/
android:
name: Android ${{ matrix.arch }}
runs-on: ubuntu-20.04
env:
ndk_version: "r25c"
ANDROID_NDK: ${{ github.workspace }}/android-ndk
strategy:
matrix:
arch: [armeabi-v7a, arm64-v8a, x86, x86_64]
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install deps
run: |
sudo rm /var/lib/man-db/auto-update
sudo apt-get update
sudo apt-get install -qyy wget unzip zip gcc-multilib make cmake
- name: Cache NDK
id: cache-ndk
uses: actions/cache@v4
with:
key: android-ndk-${{ env.ndk_version }}-linux
path: ${{ env.ANDROID_NDK }}
- name: Install NDK
run: |
wget --progress=bar:force "http://dl.google.com/android/repository/android-ndk-${ndk_version}-linux.zip"
unzip -q "android-ndk-${ndk_version}-linux.zip"
rm "android-ndk-${ndk_version}-linux.zip"
mv "android-ndk-${ndk_version}" "${ANDROID_NDK}"
if: ${{ steps.cache-ndk.outputs.cache-hit != 'true' }}
- name: Build
run: ./scripts/ci-build-android.sh ${{ matrix.arch }}
#- name: Upload Artifact
# uses: actions/upload-artifact@v4
# with:
# name: irrlicht-android-${{ matrix.arch }}
# path: ${{ runner.temp }}/pkg/${{ matrix.arch }}

25
irr/.gitignore vendored Normal file
View File

@ -0,0 +1,25 @@
CMakeFiles
CMakeCache.txt
cmake_install.cmake
install_manifest.txt
IrrlichtMtConfig.cmake
IrrlichtMtConfigVersion.cmake
IrrlichtMtTargets.cmake
CTestTestfile.cmake
Makefile
libs/*
*.so*
*.a
*.exe
*.dll
bin/Linux
scripts/gl2ext.h
scripts/glcorearb.h
scripts/glext.h
*.vcxproj*
*.dir/
*.sln
*visualstudio/
# vscode cmake plugin
build/*

82
irr/CMakeLists.txt Normal file
View File

@ -0,0 +1,82 @@
cmake_minimum_required(VERSION 3.12)
set(IRRLICHTMT_REVISION 15)
project(Irrlicht
VERSION 1.9.0.${IRRLICHTMT_REVISION}
LANGUAGES CXX
)
message(STATUS "*** Building IrrlichtMt ${PROJECT_VERSION} ***")
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
include(GNUInstallDirs)
if(ANDROID)
set(sysname Android)
elseif(APPLE)
set(sysname OSX)
elseif(MSVC)
set(sysname Win32-VisualStudio)
elseif(WIN32)
set(sysname Win32-gcc)
else()
set(sysname Linux)
endif()
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib/${sysname})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin/${sysname})
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type: Debug or Release" FORCE)
endif()
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
enable_testing()
add_subdirectory(src)
add_subdirectory(test)
option(BUILD_EXAMPLES "Build example applications" FALSE)
if(BUILD_EXAMPLES)
add_subdirectory(examples)
endif()
# Export a file that describes the targets that IrrlichtMt creates.
# The file is placed in the location FILE points to, where CMake can easily
# locate it by pointing CMAKE_PREFIX_PATH to this project root.
export(EXPORT IrrlichtMt-export
FILE "${CMAKE_CURRENT_BINARY_DIR}/cmake/IrrlichtMtTargets.cmake"
NAMESPACE IrrlichtMt::
)
# Installation of headers.
install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/"
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/irrlichtmt"
)
# Installation of CMake target and configuration files.
install(EXPORT IrrlichtMt-export
FILE IrrlichtMtTargets.cmake
NAMESPACE IrrlichtMt::
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/IrrlichtMt"
)
include(CMakePackageConfigHelpers)
configure_package_config_file("${PROJECT_SOURCE_DIR}/Config.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/cmake/IrrlichtMtConfig.cmake"
INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/IrrlichtMt"
NO_SET_AND_CHECK_MACRO
NO_CHECK_REQUIRED_COMPONENTS_MACRO
)
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/cmake/IrrlichtMtConfigVersion.cmake"
COMPATIBILITY AnyNewerVersion
)
install(FILES
"${CMAKE_CURRENT_BINARY_DIR}/cmake/IrrlichtMtConfig.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/cmake/IrrlichtMtConfigVersion.cmake"
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/IrrlichtMt"
)

11
irr/Config.cmake.in Normal file
View File

@ -0,0 +1,11 @@
@PACKAGE_INIT@
include(CMakeFindDependencyMacro)
if(NOT TARGET IrrlichtMt::IrrlichtMt)
# private dependency only explicitly needed with static libs
if(@USE_SDL2@ AND NOT @BUILD_SHARED_LIBS@)
find_dependency(SDL2)
endif()
include("${CMAKE_CURRENT_LIST_DIR}/IrrlichtMtTargets.cmake")
endif()

26
irr/LICENSE Normal file
View File

@ -0,0 +1,26 @@
Copyright (C) 2002-2012 Nikolaus Gebhardt
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
Please note that the Irrlicht Engine is based in part on the work of the
Independent JPEG Group, the zlib, libPng and aesGladman. This means that if you use
the Irrlicht Engine in your product, you must acknowledge somewhere in your
documentation that you've used the IJPG code. It would also be nice to mention
that you use the Irrlicht Engine, the zlib, libPng and aesGladman. See the
corresponding license files for further informations. It is also possible to disable
usage of those additional libraries by defines in the IrrCompileConfig.h header and
recompiling the engine.

88
irr/README.md Normal file
View File

@ -0,0 +1,88 @@
IrrlichtMt version 1.9
======================
IrrlichtMt is the 3D engine of [Minetest](https://github.com/minetest).
It is based on the [Irrlicht Engine](https://irrlicht.sourceforge.io/) but is now developed independently.
It is intentionally not compatible to upstream and is planned to be eventually absorbed into Minetest.
Build
-----
The build system is CMake.
The following libraries are required to be installed:
* zlib, libPNG, libJPEG
* OpenGL
* or on mobile: OpenGL ES (can be optionally enabled on desktop too)
* on Unix: X11
* SDL2 (see below)
Aside from standard search options (`ZLIB_INCLUDE_DIR`, `ZLIB_LIBRARY`, ...) the following options are available:
* `BUILD_SHARED_LIBS` (default: `ON`) - Build IrrlichtMt as a shared library
* `BUILD_EXAMPLES` (default: `OFF`) - Build example applications
* `ENABLE_OPENGL` - Enable OpenGL driver
* `ENABLE_OPENGL3` (default: `OFF`) - Enable OpenGL 3+ driver
* `ENABLE_GLES1` - Enable OpenGL ES driver, legacy
* `ENABLE_GLES2` - Enable OpenGL ES 2+ driver
* `USE_SDL2` (default: platform-dependent, usually `ON`) - Use SDL2 instead of older native device code
e.g. on a Linux system you might want to build for local use like this:
git clone https://github.com/minetest/irrlicht
cd irrlicht
cmake . -DBUILD_SHARED_LIBS=OFF
make -j$(nproc)
This will put an IrrlichtMtTargets.cmake file into the cmake directory in the current build directory, and it can then be imported from another project by pointing `find_package()` to the build directory, or by setting the `CMAKE_PREFIX_PATH` variable to that same path.
on Windows system:
It is highly recommended to use vcpkg as package manager.
After you successfully built vcpkg you can easily install the required libraries:
vcpkg install zlib libjpeg-turbo libpng sdl2 --triplet x64-windows
Run the following script in PowerShell:
git clone https://github.com/minetest/irrlicht
cd irrlicht
cmake -B build -G "Visual Studio 17 2022" -A "Win64" -DCMAKE_TOOLCHAIN_FILE=[vcpkg-root]/scripts/buildsystems/vcpkg.cmake -DBUILD_SHARED_LIBS=OFF
cmake --build build --config Release
Platforms
---------
We aim to support these platforms:
* Windows via MinGW
* Linux (GL or GLES)
* macOS
* Android
This doesn't mean other platforms don't work or won't be supported, if you find something that doesn't work contributions are welcome.
License
-------
The license of the Irrlicht Engine is based on the zlib/libpng license and applies to this fork, too.
The Irrlicht Engine License
===========================
Copyright (C) 2002-2012 Nikolaus Gebhardt
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgement in the product documentation would be
appreciated but is not required.
2. Altered source versions must be clearly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.

38
irr/cmake/FindOpenGLES2.cmake Normal file
View File

@ -0,0 +1,38 @@
#-------------------------------------------------------------------
# The contents of this file are placed in the public domain. Feel
# free to make use of it in any way you like.
#-------------------------------------------------------------------
# Try to find OpenGL ES 2 and EGL
if(WIN32)
find_path(OPENGLES2_INCLUDE_DIR GLES2/gl2.h)
find_library(OPENGLES2_LIBRARY libGLESv2)
elseif(APPLE)
find_library(OPENGLES2_LIBRARY OpenGLES REQUIRED) # framework
else()
# Unix
find_path(OPENGLES2_INCLUDE_DIR GLES2/gl2.h
PATHS /usr/X11R6/include /usr/include
)
find_library(OPENGLES2_LIBRARY
NAMES GLESv2
PATHS /usr/X11R6/lib /usr/lib
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(OpenGLES2 DEFAULT_MSG OPENGLES2_LIBRARY OPENGLES2_INCLUDE_DIR)
find_path(EGL_INCLUDE_DIR EGL/egl.h
PATHS /usr/X11R6/include /usr/include
)
find_library(EGL_LIBRARY
NAMES EGL
PATHS /usr/X11R6/lib /usr/lib
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(EGL REQUIRED_VARS EGL_LIBRARY EGL_INCLUDE_DIR NAME_MISMATCHED)
endif()
set(OPENGLES2_LIBRARIES ${OPENGLES2_LIBRARY} ${EGL_LIBRARY})

154
irr/examples/AutomatedTest/main.cpp Normal file
View File

@ -0,0 +1,154 @@
#include <iostream>
#include <irrlicht.h>
#include "exampleHelper.h"
using namespace irr;
static IrrlichtDevice *device = nullptr;
static int test_fail = 0;
void test_irr_array();
void test_irr_string();
static video::E_DRIVER_TYPE chooseDriver(core::stringc arg_)
{
if (arg_ == "null")
return video::EDT_NULL;
if (arg_ == "ogles1")
return video::EDT_OGLES1;
if (arg_ == "ogles2")
return video::EDT_OGLES2;
if (arg_ == "opengl")
return video::EDT_OPENGL;
if (arg_ == "opengl3")
return video::EDT_OPENGL3;
std::cerr << "Unknown driver type: " << arg_.c_str() << ". Trying OpenGL." << std::endl;
return video::EDT_OPENGL;
}
static inline void check(bool ok, const char *msg)
{
if (!ok) {
test_fail++;
device->getLogger()->log((core::stringc("FAILED TEST: ") + msg).c_str(), ELL_ERROR);
}
}
void run_unit_tests()
{
std::cout << "Running unit tests:" << std::endl;
try {
test_irr_array();
test_irr_string();
} catch (const std::exception &e) {
std::cerr << e.what() << std::endl;
test_fail++;
}
std::cout << std::endl;
}
int main(int argc, char *argv[])
{
run_unit_tests();
SIrrlichtCreationParameters p;
p.DriverType = chooseDriver(argc > 1 ? argv[1] : "");
p.WindowSize = core::dimension2du(640, 480);
p.Vsync = true;
p.LoggingLevel = ELL_DEBUG;
device = createDeviceEx(p);
if (!device)
return 1;
{
u32 total = 0;
device->getOSOperator()->getSystemMemory(&total, nullptr);
core::stringc message = core::stringc("Total RAM in MiB: ") + core::stringc(total >> 10);
device->getLogger()->log(message.c_str(), ELL_INFORMATION);
check(total > 130 * 1024, "RAM amount");
}
device->setWindowCaption(L"Hello World!");
device->setResizable(true);
video::IVideoDriver *driver = device->getVideoDriver();
scene::ISceneManager *smgr = device->getSceneManager();
gui::IGUIEnvironment *guienv = device->getGUIEnvironment();
guienv->addStaticText(L"sample text", core::rect<s32>(10, 10, 110, 22), false);
gui::IGUIButton *button = guienv->addButton(
core::rect<s32>(10, 30, 110, 30 + 32), 0, -1, L"sample button",
L"sample tooltip");
gui::IGUIEditBox *editbox = guienv->addEditBox(L"",
core::rect<s32>(10, 70, 60, 70 + 16));
const io::path mediaPath = getExampleMediaPath();
auto mesh_file = device->getFileSystem()->createAndOpenFile(mediaPath + "coolguy_opt.x");
check(mesh_file, "mesh file loading");
scene::IAnimatedMesh *mesh = smgr->getMesh(mesh_file);
check(mesh, "mesh loading");
if (mesh_file)
mesh_file->drop();
if (mesh) {
video::ITexture *tex = driver->getTexture(mediaPath + "cooltexture.png");
check(tex, "texture loading");
scene::IAnimatedMeshSceneNode *node = smgr->addAnimatedMeshSceneNode(mesh);
if (node) {
node->forEachMaterial([tex](video::SMaterial &mat) {
mat.Lighting = false;
mat.setTexture(0, tex);
});
node->setFrameLoop(0, 29);
node->setAnimationSpeed(30);
}
}
smgr->addCameraSceneNode(0, core::vector3df(0, 4, 5), core::vector3df(0, 2, 0));
s32 n = 0;
SEvent event;
device->getTimer()->start();
while (device->run()) {
if (device->getTimer()->getTime() >= 1000) {
device->getTimer()->setTime(0);
++n;
if (n == 1) { // Tooltip display
bzero(&event, sizeof(SEvent));
event.EventType = irr::EET_MOUSE_INPUT_EVENT;
event.MouseInput.Event = irr::EMIE_MOUSE_MOVED;
event.MouseInput.X = button->getAbsolutePosition().getCenter().X;
event.MouseInput.Y = button->getAbsolutePosition().getCenter().Y;
device->postEventFromUser(event);
} else if (n == 2) // Text input focus
guienv->setFocus(editbox);
else if (n == 3) { // Keypress for Text input
bzero(&event, sizeof(SEvent));
event.EventType = irr::EET_KEY_INPUT_EVENT;
event.KeyInput.Char = L'a';
event.KeyInput.Key = KEY_KEY_A;
event.KeyInput.PressedDown = true;
device->postEventFromUser(event);
event.KeyInput.PressedDown = false;
device->postEventFromUser(event);
} else
device->closeDevice();
}
driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH,
video::SColor(255, 100, 100, 150));
smgr->drawAll();
guienv->drawAll();
driver->endScene();
}
check(core::stringw(L"a") == editbox->getText(), "EditBox text");
device->getLogger()->log("Done.", ELL_INFORMATION);
device->drop();
return test_fail > 0 ? 1 : 0;
}

138
irr/examples/AutomatedTest/test_array.cpp Normal file
View File

@ -0,0 +1,138 @@
#include <irrArray.h>
#include "test_helper.h"
using namespace irr;
using core::array;
static void test_basics()
{
array<int> v;
v.push_back(1); // 1
v.push_front(2); // 2, 1
v.insert(4, 0); // 4, 2, 1
v.insert(3, 1); // 4, 3, 2, 1
v.insert(0, 4); // 4, 3, 2, 1, 0
UASSERTEQ(v.size(), 5);
UASSERTEQ(v[0], 4);
UASSERTEQ(v[1], 3);
UASSERTEQ(v[2], 2);
UASSERTEQ(v[3], 1);
UASSERTEQ(v[4], 0);
array<int> w = v;
UASSERTEQ(w.size(), 5);
UASSERT(w == v);
w.clear();
UASSERTEQ(w.size(), 0);
UASSERTEQ(w.allocated_size(), 0);
UASSERT(w.empty());
w = v;
UASSERTEQ(w.size(), 5);
w.set_used(3);
UASSERTEQ(w.size(), 3);
UASSERTEQ(w[0], 4);
UASSERTEQ(w[1], 3);
UASSERTEQ(w[2], 2);
UASSERTEQ(w.getLast(), 2);
w.set_used(20);
UASSERTEQ(w.size(), 20);
w = v;
w.sort();
UASSERTEQ(w.size(), 5);
UASSERTEQ(w[0], 0);
UASSERTEQ(w[1], 1);
UASSERTEQ(w[2], 2);
UASSERTEQ(w[3], 3);
UASSERTEQ(w[4], 4);
w.erase(0);
UASSERTEQ(w.size(), 4);
UASSERTEQ(w[0], 1);
UASSERTEQ(w[1], 2);
UASSERTEQ(w[2], 3);
UASSERTEQ(w[3], 4);
w.erase(1, 2);
UASSERTEQ(w.size(), 2);
UASSERTEQ(w[0], 1);
UASSERTEQ(w[1], 4);
w.swap(v);
UASSERTEQ(w.size(), 5);
UASSERTEQ(v.size(), 2);
}
static void test_linear_searches()
{
// Populate the array with 0, 1, 2, ..., 100, 100, 99, 98, 97, ..., 0
array<int> arr;
for (int i = 0; i <= 100; i++)
arr.push_back(i);
for (int i = 100; i >= 0; i--)
arr.push_back(i);
s32 end = arr.size() - 1;
for (int i = 0; i <= 100; i++) {
s32 index = arr.linear_reverse_search(i);
UASSERTEQ(index, end - i);
}
for (int i = 0; i <= 100; i++) {
s32 index = arr.linear_search(i);
UASSERTEQ(index, i);
}
}
static void test_binary_searches()
{
const auto &values = {3, 5, 1, 2, 5, 10, 19, 9, 7, 1, 2, 5, 8, 15};
array<int> arr;
for (int value : values) {
arr.push_back(value);
}
// Test the const form first, it uses a linear search without sorting
const array<int> &carr = arr;
UASSERTEQ(carr.binary_search(20), -1);
UASSERTEQ(carr.binary_search(0), -1);
UASSERTEQ(carr.binary_search(1), 2);
// Sorted: 1, 1, 2, 2, 3, 5, 5, 5, 7, 8, 9, 10, 15, 19
UASSERTEQ(arr.binary_search(20), -1);
UASSERTEQ(arr.binary_search(0), -1);
for (int value : values) {
s32 i = arr.binary_search(value);
UASSERTNE(i, -1);
UASSERTEQ(arr[i], value);
}
s32 first, last;
first = arr.binary_search_multi(1, last);
UASSERTEQ(first, 0);
UASSERTEQ(last, 1);
first = arr.binary_search_multi(2, last);
UASSERTEQ(first, 2);
UASSERTEQ(last, 3);
first = arr.binary_search_multi(3, last);
UASSERTEQ(first, 4);
UASSERTEQ(last, 4);
first = arr.binary_search_multi(4, last);
UASSERTEQ(first, -1);
first = arr.binary_search_multi(5, last);
UASSERTEQ(first, 5);
UASSERTEQ(last, 7);
first = arr.binary_search_multi(7, last);
UASSERTEQ(first, 8);
UASSERTEQ(last, 8);
first = arr.binary_search_multi(19, last);
UASSERTEQ(first, 13);
UASSERTEQ(last, 13);
}
void test_irr_array()
{
test_basics();
test_linear_searches();
test_binary_searches();
std::cout << " test_irr_array PASSED" << std::endl;
}

33
irr/examples/AutomatedTest/test_helper.h Normal file
View File

@ -0,0 +1,33 @@
#pragma once
#include <exception>
#include <iostream>
class TestFailedException : public std::exception
{
};
// Asserts the comparison specified by CMP is true, or fails the current unit test
#define UASSERTCMP(CMP, actual, expected) \
do { \
const auto &a = (actual); \
const auto &e = (expected); \
if (!CMP(a, e)) { \
std::cout \
<< "Test assertion failed: " << #actual << " " << #CMP << " " \
<< #expected << std::endl \
<< " at " << __FILE__ << ":" << __LINE__ << std::endl \
<< " actual: " << a << std::endl \
<< " expected: " \
<< e << std::endl; \
throw TestFailedException(); \
} \
} while (0)
#define CMPEQ(a, e) (a == e)
#define CMPTRUE(a, e) (a)
#define CMPNE(a, e) (a != e)
#define UASSERTEQ(actual, expected) UASSERTCMP(CMPEQ, actual, expected)
#define UASSERTNE(actual, nexpected) UASSERTCMP(CMPNE, actual, nexpected)
#define UASSERT(actual) UASSERTCMP(CMPTRUE, actual, true)

205
irr/examples/AutomatedTest/test_string.cpp Normal file
View File

@ -0,0 +1,205 @@
#include <irrString.h>
#include <cstring>
#include <clocale>
#include <vector>
#include "test_helper.h"
using namespace irr;
using namespace irr::core;
#define CMPSTR(a, b) (!strcmp(a, b))
#define UASSERTSTR(actual, expected) UASSERTCMP(CMPSTR, actual.c_str(), expected)
static void test_basics()
{
// ctor
stringc s;
UASSERTEQ(s.c_str()[0], '\0');
s = stringc(0.1234567);
UASSERTSTR(s, "0.123457");
s = stringc(0x1p+53);
UASSERTSTR(s, "9007199254740992.000000");
s = stringc(static_cast<int>(-102400));
UASSERTSTR(s, "-102400");
s = stringc(static_cast<unsigned int>(102400));
UASSERTSTR(s, "102400");
s = stringc(static_cast<long>(-1024000));
UASSERTSTR(s, "-1024000");
s = stringc(static_cast<unsigned long>(1024000));
UASSERTSTR(s, "1024000");
s = stringc("YESno", 3);
UASSERTSTR(s, "YES");
s = stringc(L"test", 4);
UASSERTSTR(s, "test");
s = stringc("Hello World!");
UASSERTSTR(s, "Hello World!");
// operator=
s = stringw(L"abcdef");
UASSERTSTR(s, "abcdef");
s = L"abcdef";
UASSERTSTR(s, "abcdef");
s = static_cast<const char *>(nullptr);
UASSERTSTR(s, "");
// operator+
s = s + stringc("foo");
UASSERTSTR(s, "foo");
s = s + L"bar";
UASSERTSTR(s, "foobar");
// the rest
s = "f";
UASSERTEQ(s[0], 'f');
const auto &sref = s;
UASSERTEQ(sref[0], 'f');
UASSERT(sref == "f");
UASSERT(sref == stringc("f"));
s = "a";
UASSERT(sref < stringc("aa"));
UASSERT(sref < stringc("b"));
UASSERT(stringc("Z") < sref);
UASSERT(!(sref < stringc("a")));
UASSERT(sref.lower_ignore_case("AA"));
UASSERT(sref.lower_ignore_case("B"));
UASSERT(!sref.lower_ignore_case("A"));
s = "dog";
UASSERT(sref != "cat");
UASSERT(sref != stringc("cat"));
}
static void test_methods()
{
stringc s;
const auto &sref = s;
s = "irrlicht";
UASSERTEQ(sref.size(), 8);
UASSERT(!sref.empty());
s.clear();
UASSERTEQ(sref.size(), 0);
UASSERT(sref.empty());
UASSERT(sref[0] == 0);
s = "\tAz#`";
s.make_lower();
UASSERTSTR(s, "\taz#`");
s.make_upper();
UASSERTSTR(s, "\tAZ#`");
UASSERT(sref.equals_ignore_case("\taz#`"));
UASSERT(sref.equals_substring_ignore_case("Z#`", 2));
s = "irrlicht";
UASSERT(sref.equalsn(stringc("irr"), 3));
UASSERT(sref.equalsn("irr", 3));
s = "fo";
s.append('o');
UASSERTSTR(s, "foo");
s.append("bar", 1);
UASSERTSTR(s, "foob");
s.append("ar", 999999);
UASSERTSTR(s, "foobar");
s = "nyan";
s.append(stringc("cat"));
UASSERTSTR(s, "nyancat");
s.append(stringc("sam"), 1);
UASSERTSTR(s, "nyancats");
s = "fbar";
s.insert(1, "ooXX", 2);
UASSERTSTR(s, "foobar");
UASSERTEQ(sref.findFirst('o'), 1);
UASSERTEQ(sref.findFirst('X'), -1);
UASSERTEQ(sref.findFirstChar("abff", 2), 3);
UASSERTEQ(sref.findFirstCharNotInList("fobb", 2), 3);
UASSERTEQ(sref.findLast('o'), 2);
UASSERTEQ(sref.findLast('X'), -1);
UASSERTEQ(sref.findLastChar("abrr", 2), 4);
UASSERTEQ(sref.findLastCharNotInList("rabb", 2), 3);
UASSERTEQ(sref.findNext('o', 2), 2);
UASSERTEQ(sref.findLast('o', 1), 1);
s = "ob-oob";
UASSERTEQ(sref.find("ob", 1), 4);
UASSERTEQ(sref.find("ob"), 0);
UASSERTEQ(sref.find("?"), -1);
s = "HOMEOWNER";
stringc s2 = sref.subString(2, 4);
UASSERTSTR(s2, "MEOW");
s2 = sref.subString(2, 4, true);
UASSERTSTR(s2, "meow");
s = "land";
s.replace('l', 's');
UASSERTSTR(s, "sand");
s = ">dog<";
s.replace("dog", "cat");
UASSERTSTR(s, ">cat<");
s.replace("cat", "horse");
UASSERTSTR(s, ">horse<");
s.replace("horse", "gnu");
UASSERTSTR(s, ">gnu<");
s = " h e l p ";
s.remove(' ');
UASSERTSTR(s, "help");
s.remove("el");
UASSERTSTR(s, "hp");
s = "irrlicht";
s.removeChars("it");
UASSERTSTR(s, "rrlch");
s = "\r\nfoo bar ";
s.trim();
UASSERTSTR(s, "foo bar");
s = "foxo";
s.erase(2);
UASSERTSTR(s, "foo");
s = "a";
s.append('\0');
s.append('b');
UASSERTEQ(s.size(), 3);
s.validate();
UASSERTEQ(s.size(), 1);
UASSERTEQ(s.lastChar(), 'a');
std::vector<stringc> res;
s = "a,,b,c";
s.split(res, ",aa", 1, true, false);
UASSERTEQ(res.size(), 3);
UASSERTSTR(res[0], "a");
UASSERTSTR(res[2], "c");
res.clear();
s.split(res, ",", 1, false, true);
UASSERTEQ(res.size(), 7);
UASSERTSTR(res[0], "a");
UASSERTSTR(res[2], "");
for (int i = 0; i < 3; i++)
UASSERTSTR(res[2 * i + 1], ",");
}
static void test_conv()
{
// locale-independent
stringw out;
utf8ToWString(out, "†††");
UASSERTEQ(out.size(), 3);
for (int i = 0; i < 3; i++)
UASSERTEQ(static_cast<u16>(out[i]), 0x2020);
stringc out2;
wStringToUTF8(out2, L"†††");
UASSERTEQ(out2.size(), 9);
for (int i = 0; i < 3; i++) {
UASSERTEQ(static_cast<u8>(out2[3 * i]), 0xe2);
UASSERTEQ(static_cast<u8>(out2[3 * i + 1]), 0x80);
UASSERTEQ(static_cast<u8>(out2[3 * i + 2]), 0xa0);
}
// locale-dependent
if (!setlocale(LC_CTYPE, "C.UTF-8"))
setlocale(LC_CTYPE, "UTF-8"); // macOS
stringw out3;
multibyteToWString(out3, "†††");
UASSERTEQ(out3.size(), 3);
for (int i = 0; i < 3; i++)
UASSERTEQ(static_cast<u16>(out3[i]), 0x2020);
}
void test_irr_string()
{
test_basics();
test_methods();
test_conv();
std::cout << " test_irr_string PASSED" << std::endl;
}

17
irr/examples/CMakeLists.txt Normal file
View File

@ -0,0 +1,17 @@
set(IRREXAMPLES
# removed
)
if(UNIX)
list(APPEND IRREXAMPLES AutomatedTest)
endif()
foreach(exname IN ITEMS ${IRREXAMPLES})
file(GLOB sources "${CMAKE_CURRENT_SOURCE_DIR}/${exname}/*.cpp")
add_executable(${exname} ${sources})
target_include_directories(${exname} PRIVATE
${CMAKE_SOURCE_DIR}/include
${CMAKE_CURRENT_SOURCE_DIR}/${exname}
)
target_link_libraries(${exname} IrrlichtMt)
endforeach()

274
irr/include/CMeshBuffer.h Normal file
View File

@ -0,0 +1,274 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "irrArray.h"
#include "IMeshBuffer.h"
namespace irr
{
namespace scene
{
//! Template implementation of the IMeshBuffer interface
template <class T>
class CMeshBuffer : public IMeshBuffer
{
public:
//! Default constructor for empty meshbuffer
CMeshBuffer() :
ChangedID_Vertex(1), ChangedID_Index(1), MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER), HWBuffer(NULL), PrimitiveType(EPT_TRIANGLES)
{
#ifdef _DEBUG
setDebugName("CMeshBuffer");
#endif
}
//! Get material of this meshbuffer
/** \return Material of this buffer */
const video::SMaterial &getMaterial() const override
{
return Material;
}
//! Get material of this meshbuffer
/** \return Material of this buffer */
video::SMaterial &getMaterial() override
{
return Material;
}
//! Get pointer to vertices
/** \return Pointer to vertices. */
const void *getVertices() const override
{
return Vertices.const_pointer();
}
//! Get pointer to vertices
/** \return Pointer to vertices. */
void *getVertices() override
{
return Vertices.pointer();
}
//! Get number of vertices
/** \return Number of vertices. */
u32 getVertexCount() const override
{
return Vertices.size();
}
//! Get type of index data which is stored in this meshbuffer.
/** \return Index type of this buffer. */
video::E_INDEX_TYPE getIndexType() const override
{
return video::EIT_16BIT;
}
//! Get pointer to indices
/** \return Pointer to indices. */
const u16 *getIndices() const override
{
return Indices.const_pointer();
}
//! Get pointer to indices
/** \return Pointer to indices. */
u16 *getIndices() override
{
return Indices.pointer();
}
//! Get number of indices
/** \return Number of indices. */
u32 getIndexCount() const override
{
return Indices.size();
}
//! Get the axis aligned bounding box
/** \return Axis aligned bounding box of this buffer. */
const core::aabbox3d<f32> &getBoundingBox() const override
{
return BoundingBox;
}
//! Set the axis aligned bounding box
/** \param box New axis aligned bounding box for this buffer. */
//! set user axis aligned bounding box
void setBoundingBox(const core::aabbox3df &box) override
{
BoundingBox = box;
}
//! Recalculate the bounding box.
/** should be called if the mesh changed. */
void recalculateBoundingBox() override
{
if (!Vertices.empty()) {
BoundingBox.reset(Vertices[0].Pos);
const irr::u32 vsize = Vertices.size();
for (u32 i = 1; i < vsize; ++i)
BoundingBox.addInternalPoint(Vertices[i].Pos);
} else
BoundingBox.reset(0, 0, 0);
}
//! Get type of vertex data stored in this buffer.
/** \return Type of vertex data. */
video::E_VERTEX_TYPE getVertexType() const override
{
return T::getType();
}
//! returns position of vertex i
const core::vector3df &getPosition(u32 i) const override
{
return Vertices[i].Pos;
}
//! returns position of vertex i
core::vector3df &getPosition(u32 i) override
{
return Vertices[i].Pos;
}
//! returns normal of vertex i
const core::vector3df &getNormal(u32 i) const override
{
return Vertices[i].Normal;
}
//! returns normal of vertex i
core::vector3df &getNormal(u32 i) override
{
return Vertices[i].Normal;
}
//! returns texture coord of vertex i
const core::vector2df &getTCoords(u32 i) const override
{
return Vertices[i].TCoords;
}
//! returns texture coord of vertex i
core::vector2df &getTCoords(u32 i) override
{
return Vertices[i].TCoords;
}
//! Append the vertices and indices to the current buffer
/** Only works for compatible types, i.e. either the same type
or the main buffer is of standard type. Otherwise, behavior is
undefined.
*/
void append(const void *const vertices, u32 numVertices, const u16 *const indices, u32 numIndices) override
{
if (vertices == getVertices())
return;
const u32 vertexCount = getVertexCount();
u32 i;
Vertices.reallocate(vertexCount + numVertices);
for (i = 0; i < numVertices; ++i) {
Vertices.push_back(static_cast<const T *>(vertices)[i]);
BoundingBox.addInternalPoint(static_cast<const T *>(vertices)[i].Pos);
}
Indices.reallocate(getIndexCount() + numIndices);
for (i = 0; i < numIndices; ++i) {
Indices.push_back(indices[i] + vertexCount);
}
}
//! get the current hardware mapping hint
E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const override
{
return MappingHint_Vertex;
}
//! get the current hardware mapping hint
E_HARDWARE_MAPPING getHardwareMappingHint_Index() const override
{
return MappingHint_Index;
}
//! set the hardware mapping hint, for driver
void setHardwareMappingHint(E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer = EBT_VERTEX_AND_INDEX) override
{
if (Buffer == EBT_VERTEX_AND_INDEX || Buffer == EBT_VERTEX)
MappingHint_Vertex = NewMappingHint;
if (Buffer == EBT_VERTEX_AND_INDEX || Buffer == EBT_INDEX)
MappingHint_Index = NewMappingHint;
}
//! Describe what kind of primitive geometry is used by the meshbuffer
void setPrimitiveType(E_PRIMITIVE_TYPE type) override
{
PrimitiveType = type;
}
//! Get the kind of primitive geometry which is used by the meshbuffer
E_PRIMITIVE_TYPE getPrimitiveType() const override
{
return PrimitiveType;
}
//! flags the mesh as changed, reloads hardware buffers
void setDirty(E_BUFFER_TYPE Buffer = EBT_VERTEX_AND_INDEX) override
{
if (Buffer == EBT_VERTEX_AND_INDEX || Buffer == EBT_VERTEX)
++ChangedID_Vertex;
if (Buffer == EBT_VERTEX_AND_INDEX || Buffer == EBT_INDEX)
++ChangedID_Index;
}
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
u32 getChangedID_Vertex() const override { return ChangedID_Vertex; }
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
u32 getChangedID_Index() const override { return ChangedID_Index; }
void setHWBuffer(void *ptr) const override
{
HWBuffer = ptr;
}
void *getHWBuffer() const override
{
return HWBuffer;
}
u32 ChangedID_Vertex;
u32 ChangedID_Index;
//! hardware mapping hint
E_HARDWARE_MAPPING MappingHint_Vertex;
E_HARDWARE_MAPPING MappingHint_Index;
mutable void *HWBuffer;
//! Material for this meshbuffer.
video::SMaterial Material;
//! Vertices of this buffer
core::array<T> Vertices;
//! Indices into the vertices of this buffer.
core::array<u16> Indices;
//! Bounding box of this meshbuffer.
core::aabbox3d<f32> BoundingBox;
//! Primitive type used for rendering (triangles, lines, ...)
E_PRIMITIVE_TYPE PrimitiveType;
};
//! Standard meshbuffer
typedef CMeshBuffer<video::S3DVertex> SMeshBuffer;
//! Meshbuffer with two texture coords per vertex, e.g. for lightmaps
typedef CMeshBuffer<video::S3DVertex2TCoords> SMeshBufferLightMap;
//! Meshbuffer with vertices having tangents stored, e.g. for normal mapping
typedef CMeshBuffer<video::S3DVertexTangents> SMeshBufferTangents;
} // end namespace scene
} // end namespace irr

32
irr/include/EAttributes.h Normal file
View File

@ -0,0 +1,32 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
namespace irr
{
namespace io
{
//! Types of attributes available for IAttributes
enum E_ATTRIBUTE_TYPE
{
// integer attribute
EAT_INT = 0,
// float attribute
EAT_FLOAT,
// boolean attribute
EAT_BOOL,
// known attribute type count
EAT_COUNT,
// unknown attribute
EAT_UNKNOWN
};
} // end namespace io
} // end namespace irr

35
irr/include/ECullingTypes.h Normal file
View File

@ -0,0 +1,35 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "irrTypes.h"
namespace irr
{
namespace scene
{
//! An enumeration for all types of automatic culling for built-in scene nodes
enum E_CULLING_TYPE
{
EAC_OFF = 0,
EAC_BOX = 1,
EAC_FRUSTUM_BOX = 2,
EAC_FRUSTUM_SPHERE = 4,
EAC_OCC_QUERY = 8
};
//! Names for culling type
const c8 *const AutomaticCullingNames[] = {
"false",
"box", // camera box against node box
"frustum_box", // camera frustum against node box
"frustum_sphere", // camera frustum against node sphere
"occ_query", // occlusion query
0,
};
} // end namespace scene
} // end namespace irr

41
irr/include/EDebugSceneTypes.h Normal file
View File

@ -0,0 +1,41 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
namespace irr
{
namespace scene
{
//! An enumeration for all types of debug data for built-in scene nodes (flags)
enum E_DEBUG_SCENE_TYPE
{
//! No Debug Data ( Default )
EDS_OFF = 0,
//! Show Bounding Boxes of SceneNode
EDS_BBOX = 1,
//! Show Vertex Normals
EDS_NORMALS = 2,
//! Shows Skeleton/Tags
EDS_SKELETON = 4,
//! Overlays Mesh Wireframe
EDS_MESH_WIRE_OVERLAY = 8,
//! Show Bounding Boxes of all MeshBuffers
EDS_BBOX_BUFFERS = 32,
//! EDS_BBOX | EDS_BBOX_BUFFERS
EDS_BBOX_ALL = EDS_BBOX | EDS_BBOX_BUFFERS,
//! Show all debug infos
EDS_FULL = 0xffffffff
};
} // end namespace scene
} // end namespace irr

46
irr/include/EDeviceTypes.h Normal file
View File

@ -0,0 +1,46 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
namespace irr
{
//! An enum for the different device types supported by the Irrlicht Engine.
enum E_DEVICE_TYPE
{
//! A device native to Microsoft Windows
/** This device uses the Win32 API and works in all versions of Windows. */
EIDT_WIN32,
//! A device native to Unix style operating systems.
/** This device uses the X11 windowing system and works in Linux, Solaris, FreeBSD, OSX and
other operating systems which support X11. */
EIDT_X11,
//! A device native to Mac OSX
/** This device uses Apple's Cocoa API and works in Mac OSX 10.2 and above. */
EIDT_OSX,
//! A device which uses Simple DirectMedia Layer
/** The SDL device works under all platforms supported by SDL but first must be compiled
in by setting the USE_SDL2 CMake option to ON */
EIDT_SDL,
//! This selection allows Irrlicht to choose the best device from the ones available.
/** If this selection is chosen then Irrlicht will try to use the IrrlichtDevice native
to your operating system. If this is unavailable then the X11, SDL and then console device
will be tried. This ensures that Irrlicht will run even if your platform is unsupported,
although it may not be able to render anything. */
EIDT_BEST,
//! A device for Android platforms
/** Best used with embedded devices and mobile systems.
Does not need X11 or other graphical subsystems.
May support hw-acceleration via OpenGL-ES */
EIDT_ANDROID,
};
} // end namespace irr

137
irr/include/EDriverFeatures.h Normal file
View File

@ -0,0 +1,137 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
namespace irr
{
namespace video
{
//! enumeration for querying features of the video driver.
enum E_VIDEO_DRIVER_FEATURE
{
//! Is driver able to render to a surface?
EVDF_RENDER_TO_TARGET = 0,
//! Is hardware transform and lighting supported?
EVDF_HARDWARE_TL,
//! Are multiple textures per material possible?
EVDF_MULTITEXTURE,
//! Is driver able to render with a bilinear filter applied?
EVDF_BILINEAR_FILTER,
//! Can the driver handle mip maps?
EVDF_MIP_MAP,
//! Can the driver update mip maps automatically?
EVDF_MIP_MAP_AUTO_UPDATE,
//! Are stencilbuffers switched on and does the device support stencil buffers?
EVDF_STENCIL_BUFFER,
//! Is Vertex Shader 1.1 supported?
EVDF_VERTEX_SHADER_1_1,
//! Is Vertex Shader 2.0 supported?
EVDF_VERTEX_SHADER_2_0,
//! Is Vertex Shader 3.0 supported?
EVDF_VERTEX_SHADER_3_0,
//! Is Pixel Shader 1.1 supported?
EVDF_PIXEL_SHADER_1_1,
//! Is Pixel Shader 1.2 supported?
EVDF_PIXEL_SHADER_1_2,
//! Is Pixel Shader 1.3 supported?
EVDF_PIXEL_SHADER_1_3,
//! Is Pixel Shader 1.4 supported?
EVDF_PIXEL_SHADER_1_4,
//! Is Pixel Shader 2.0 supported?
EVDF_PIXEL_SHADER_2_0,
//! Is Pixel Shader 3.0 supported?
EVDF_PIXEL_SHADER_3_0,
//! Are ARB vertex programs v1.0 supported?
EVDF_ARB_VERTEX_PROGRAM_1,
//! Are ARB fragment programs v1.0 supported?
EVDF_ARB_FRAGMENT_PROGRAM_1,
//! Is GLSL supported?
EVDF_ARB_GLSL,
//! Is HLSL supported?
EVDF_HLSL,
//! Are non-square textures supported?
EVDF_TEXTURE_NSQUARE,
//! Are non-power-of-two textures supported?
EVDF_TEXTURE_NPOT,
//! Are framebuffer objects supported?
EVDF_FRAMEBUFFER_OBJECT,
//! Are vertex buffer objects supported?
EVDF_VERTEX_BUFFER_OBJECT,
//! Supports Alpha To Coverage
EVDF_ALPHA_TO_COVERAGE,
//! Supports Color masks (disabling color planes in output)
EVDF_COLOR_MASK,
//! Supports multiple render targets at once
EVDF_MULTIPLE_RENDER_TARGETS,
//! Supports separate blend settings for multiple render targets
EVDF_MRT_BLEND,
//! Supports separate color masks for multiple render targets
EVDF_MRT_COLOR_MASK,
//! Supports separate blend functions for multiple render targets
EVDF_MRT_BLEND_FUNC,
//! Supports geometry shaders
EVDF_GEOMETRY_SHADER,
//! Supports occlusion queries
EVDF_OCCLUSION_QUERY,
//! Supports polygon offset/depth bias for avoiding z-fighting
EVDF_POLYGON_OFFSET,
//! Support for different blend functions. Without, only ADD is available
EVDF_BLEND_OPERATIONS,
//! Support for separate blending for RGB and Alpha.
EVDF_BLEND_SEPARATE,
//! Support for texture coord transformation via texture matrix
EVDF_TEXTURE_MATRIX,
//! Support for cube map textures.
EVDF_TEXTURE_CUBEMAP,
//! Support for filtering across different faces of the cubemap
EVDF_TEXTURE_CUBEMAP_SEAMLESS,
//! Support for clamping vertices beyond far-plane to depth instead of capping them.
EVDF_DEPTH_CLAMP,
//! Only used for counting the elements of this enum
EVDF_COUNT
};
} // end namespace video
} // end namespace irr

44
irr/include/EDriverTypes.h Normal file
View File

@ -0,0 +1,44 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "irrTypes.h"
namespace irr
{
namespace video
{
//! An enum for all types of drivers the Irrlicht Engine supports.
enum E_DRIVER_TYPE
{
//! Null driver, useful for applications to run the engine without visualization.
/** The null device is able to load textures, but does not
render and display any graphics. */
EDT_NULL,
//! OpenGL device, available on most platforms.
/** Performs hardware accelerated rendering of 3D and 2D
primitives. */
EDT_OPENGL,
//! OpenGL-ES 1.x driver, for embedded and mobile systems
EDT_OGLES1,
//! OpenGL-ES 2.x driver, for embedded and mobile systems
/** Supports shaders etc. */
EDT_OGLES2,
//! WebGL1 friendly subset of OpenGL-ES 2.x driver for Emscripten
EDT_WEBGL1,
EDT_OPENGL3,
//! No driver, just for counting the elements
EDT_COUNT
};
} // end namespace video
} // end namespace irr

34
irr/include/EFocusFlags.h Normal file
View File

@ -0,0 +1,34 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
namespace irr
{
namespace gui
{
//! Bitflags for defining the the focus behavior of the gui
// (all names start with SET as we might add REMOVE flags later to control that behavior as well)
enum EFOCUS_FLAG
{
//! When set the focus changes when the left mouse-button got clicked while over an element
EFF_SET_ON_LMOUSE_DOWN = 0x1,
//! When set the focus changes when the right mouse-button got clicked while over an element
//! Note that elements usually don't care about right-click and that won't change with this flag
//! This is mostly to allow taking away focus from elements with right-mouse additionally.
EFF_SET_ON_RMOUSE_DOWN = 0x2,
//! When set the focus changes when the mouse-cursor is over an element
EFF_SET_ON_MOUSE_OVER = 0x4,
//! When set the focus can be changed with TAB-key combinations.
EFF_SET_ON_TAB = 0x8,
//! When set it's possible to set the focus to disabled elements.
EFF_CAN_FOCUS_DISABLED = 0x16
};
} // namespace gui
} // namespace irr

35
irr/include/EGUIAlignment.h Normal file
View File

@ -0,0 +1,35 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "irrTypes.h"
namespace irr
{
namespace gui
{
enum EGUI_ALIGNMENT
{
//! Aligned to parent's top or left side (default)
EGUIA_UPPERLEFT = 0,
//! Aligned to parent's bottom or right side
EGUIA_LOWERRIGHT,
//! Aligned to the center of parent
EGUIA_CENTER,
//! Stretched to fit parent
EGUIA_SCALE
};
//! Names for alignments
const c8 *const GUIAlignmentNames[] = {
"upperLeft",
"lowerRight",
"center",
"scale",
0,
};
} // namespace gui
} // namespace irr

133
irr/include/EGUIElementTypes.h Normal file
View File

@ -0,0 +1,133 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "irrTypes.h"
namespace irr
{
namespace gui
{
//! List of all basic Irrlicht GUI elements.
/** An IGUIElement returns this when calling IGUIElement::getType(); */
enum EGUI_ELEMENT_TYPE
{
//! A button (IGUIButton)
EGUIET_BUTTON = 0,
//! A check box (IGUICheckBox)
EGUIET_CHECK_BOX,
//! A combo box (IGUIComboBox)
EGUIET_COMBO_BOX,
//! A context menu (IGUIContextMenu)
EGUIET_CONTEXT_MENU,
//! A menu (IGUIMenu)
EGUIET_MENU,
//! An edit box (IGUIEditBox)
EGUIET_EDIT_BOX,
//! A file open dialog (IGUIFileOpenDialog)
EGUIET_FILE_OPEN_DIALOG,
//! A color select open dialog (IGUIColorSelectDialog)
EGUIET_COLOR_SELECT_DIALOG,
//! A in/out fader (IGUIInOutFader)
EGUIET_IN_OUT_FADER,
//! An image (IGUIImage)
EGUIET_IMAGE,
//! A list box (IGUIListBox)
EGUIET_LIST_BOX,
//! A mesh viewer (IGUIMeshViewer)
EGUIET_MESH_VIEWER,
//! A message box (IGUIWindow)
EGUIET_MESSAGE_BOX,
//! A modal screen
EGUIET_MODAL_SCREEN,
//! A scroll bar (IGUIScrollBar)
EGUIET_SCROLL_BAR,
//! A spin box (IGUISpinBox)
EGUIET_SPIN_BOX,
//! A static text (IGUIStaticText)
EGUIET_STATIC_TEXT,
//! A tab (IGUITab)
EGUIET_TAB,
//! A tab control
EGUIET_TAB_CONTROL,
//! A Table
EGUIET_TABLE,
//! A tool bar (IGUIToolBar)
EGUIET_TOOL_BAR,
//! A Tree View
EGUIET_TREE_VIEW,
//! A window
EGUIET_WINDOW,
//! Unknown type.
EGUIET_ELEMENT,
//! The root of the GUI
EGUIET_ROOT,
//! Not an element, amount of elements in there
EGUIET_COUNT,
//! This enum is never used, it only forces the compiler to compile this enumeration to 32 bit.
EGUIET_FORCE_32_BIT = 0x7fffffff
};
//! Names for built-in element types
const c8 *const GUIElementTypeNames[] = {
"button",
"checkBox",
"comboBox",
"contextMenu",
"menu",
"editBox",
"fileOpenDialog",
"colorSelectDialog",
"inOutFader",
"image",
"listBox",
"meshViewer",
"messageBox",
"modalScreen",
"scrollBar",
"spinBox",
"staticText",
"tab",
"tabControl",
"table",
"toolBar",
"treeview",
"window",
"element",
"root",
"profiler",
0,
};
} // end namespace gui
} // end namespace irr

40
irr/include/EHardwareBufferFlags.h Normal file
View File

@ -0,0 +1,40 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
namespace irr
{
namespace scene
{
enum E_HARDWARE_MAPPING
{
//! Don't store on the hardware
EHM_NEVER = 0,
//! Rarely changed, usually stored completely on the hardware
EHM_STATIC,
//! Sometimes changed, driver optimized placement
EHM_DYNAMIC,
//! Always changed, cache optimizing on the GPU
EHM_STREAM
};
enum E_BUFFER_TYPE
{
//! Does not change anything
EBT_NONE = 0,
//! Change the vertex mapping
EBT_VERTEX,
//! Change the index mapping
EBT_INDEX,
//! Change both vertex and index mapping to the same value
EBT_VERTEX_AND_INDEX
};
} // end namespace scene
} // end namespace irr

82
irr/include/EMaterialProps.h Normal file
View File

@ -0,0 +1,82 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
namespace irr
{
namespace video
{
//! Material properties
enum E_MATERIAL_PROP
{
//! Corresponds to SMaterial::Wireframe.
EMP_WIREFRAME = 0x1,
//! Corresponds to SMaterial::PointCloud.
EMP_POINTCLOUD = 0x2,
//! Corresponds to SMaterial::GouraudShading.
EMP_GOURAUD_SHADING = 0x4,
//! Corresponds to SMaterial::Lighting.
EMP_LIGHTING = 0x8,
//! Corresponds to SMaterial::ZBuffer.
EMP_ZBUFFER = 0x10,
//! Corresponds to SMaterial::ZWriteEnable.
EMP_ZWRITE_ENABLE = 0x20,
//! Corresponds to SMaterial::BackfaceCulling.
EMP_BACK_FACE_CULLING = 0x40,
//! Corresponds to SMaterial::FrontfaceCulling.
EMP_FRONT_FACE_CULLING = 0x80,
//! Corresponds to SMaterialLayer::MinFilter.
EMP_MIN_FILTER = 0x100,
//! Corresponds to SMaterialLayer::MagFilter.
EMP_MAG_FILTER = 0x200,
//! Corresponds to SMaterialLayer::AnisotropicFilter.
EMP_ANISOTROPIC_FILTER = 0x400,
//! Corresponds to SMaterial::FogEnable.
EMP_FOG_ENABLE = 0x800,
//! Corresponds to SMaterial::NormalizeNormals.
EMP_NORMALIZE_NORMALS = 0x1000,
//! Corresponds to SMaterialLayer::TextureWrapU, TextureWrapV and
//! TextureWrapW.
EMP_TEXTURE_WRAP = 0x2000,
//! Corresponds to SMaterial::AntiAliasing.
EMP_ANTI_ALIASING = 0x4000,
//! Corresponds to SMaterial::ColorMask.
EMP_COLOR_MASK = 0x8000,
//! Corresponds to SMaterial::ColorMaterial.
EMP_COLOR_MATERIAL = 0x10000,
//! Corresponds to SMaterial::UseMipMaps.
EMP_USE_MIP_MAPS = 0x20000,
//! Corresponds to SMaterial::BlendOperation.
EMP_BLEND_OPERATION = 0x40000,
//! Corresponds to SMaterial::PolygonOffsetFactor, PolygonOffsetDirection,
//! PolygonOffsetDepthBias and PolygonOffsetSlopeScale.
EMP_POLYGON_OFFSET = 0x80000,
//! Corresponds to SMaterial::BlendFactor.
EMP_BLEND_FACTOR = 0x100000,
};
} // end namespace video
} // end namespace irr

74
irr/include/EMaterialTypes.h Normal file
View File

@ -0,0 +1,74 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "irrTypes.h"
namespace irr
{
namespace video
{
//! Abstracted and easy to use fixed function/programmable pipeline material modes.
enum E_MATERIAL_TYPE
{
//! Standard solid material.
/** Only first texture is used, which is supposed to be the
diffuse material. */
EMT_SOLID = 0,
//! Makes the material transparent based on the texture alpha channel.
/** The final color is blended together from the destination
color and the texture color, using the alpha channel value as
blend factor. Only first texture is used. If you are using
this material with small textures, it is a good idea to load
the texture in 32 bit mode
(video::IVideoDriver::setTextureCreationFlag()). Also, an alpha
ref is used, which can be manipulated using
SMaterial::MaterialTypeParam. This value controls how sharp the
edges become when going from a transparent to a solid spot on
the texture. */
EMT_TRANSPARENT_ALPHA_CHANNEL,
//! Makes the material transparent based on the texture alpha channel.
/** If the alpha channel value is greater than 127, a
pixel is written to the target, otherwise not. This
material does not use alpha blending and is a lot faster
than EMT_TRANSPARENT_ALPHA_CHANNEL. It is ideal for drawing
stuff like leaves of plants, because the borders are not
blurry but sharp. Only first texture is used. If you are
using this material with small textures and 3d object, it
is a good idea to load the texture in 32 bit mode
(video::IVideoDriver::setTextureCreationFlag()). */
EMT_TRANSPARENT_ALPHA_CHANNEL_REF,
//! Makes the material transparent based on the vertex alpha value.
EMT_TRANSPARENT_VERTEX_ALPHA,
//! BlendFunc = source * sourceFactor + dest * destFactor ( E_BLEND_FUNC )
/** Using only first texture. Generic blending method.
The blend function is set to SMaterial::MaterialTypeParam with
pack_textureBlendFunc (for 2D) or pack_textureBlendFuncSeparate (for 3D). */
EMT_ONETEXTURE_BLEND,
//! This value is not used. It only forces this enumeration to compile to 32 bit.
EMT_FORCE_32BIT = 0x7fffffff
};
//! Array holding the built in material type names
const char *const sBuiltInMaterialTypeNames[] = {
"solid",
"trans_alphach",
"trans_alphach_ref",
"trans_vertex_alpha",
"onetexture_blend",
0,
};
constexpr u32 numBuiltInMaterials =
sizeof(sBuiltInMaterialTypeNames) / sizeof(char *) - 1;
} // end namespace video
} // end namespace irr

43
irr/include/EPrimitiveTypes.h Normal file
View File

@ -0,0 +1,43 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
namespace irr
{
namespace scene
{
//! Enumeration for all primitive types there are.
enum E_PRIMITIVE_TYPE
{
//! All vertices are non-connected points.
EPT_POINTS = 0,
//! All vertices form a single connected line.
EPT_LINE_STRIP,
//! Just as LINE_STRIP, but the last and the first vertex is also connected.
EPT_LINE_LOOP,
//! Every two vertices are connected creating n/2 lines.
EPT_LINES,
//! After the first two vertices each vertex defines a new triangle.
//! Always the two last and the new one form a new triangle.
EPT_TRIANGLE_STRIP,
//! After the first two vertices each vertex defines a new triangle.
//! All around the common first vertex.
EPT_TRIANGLE_FAN,
//! Explicitly set all vertices for each triangle.
EPT_TRIANGLES,
//! The single vertices are expanded to quad billboards on the GPU.
EPT_POINT_SPRITES
};
} // end namespace scene
} // end namespace irr

30
irr/include/EReadFileType.h Normal file
View File

@ -0,0 +1,30 @@
// Copyright (C) Michael Zeilfelder
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "irrTypes.h"
namespace irr
{
namespace io
{
//! An enumeration for different class types implementing IReadFile
enum EREAD_FILE_TYPE
{
//! CReadFile
ERFT_READ_FILE = MAKE_IRR_ID('r', 'e', 'a', 'd'),
//! CMemoryReadFile
ERFT_MEMORY_READ_FILE = MAKE_IRR_ID('r', 'm', 'e', 'm'),
//! CLimitReadFile
ERFT_LIMIT_READ_FILE = MAKE_IRR_ID('r', 'l', 'i', 'm'),
//! Unknown type
EFIT_UNKNOWN = MAKE_IRR_ID('u', 'n', 'k', 'n')
};
} // end namespace io
} // end namespace irr

49
irr/include/ESceneNodeTypes.h Normal file
View File

@ -0,0 +1,49 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "irrTypes.h"
namespace irr
{
namespace scene
{
//! An enumeration for all types of built-in scene nodes
/** A scene node type is represented by a four character code
such as 'cube' or 'mesh' instead of simple numbers, to avoid
name clashes with external scene nodes.*/
enum ESCENE_NODE_TYPE
{
//! of type CSceneManager (note that ISceneManager is not(!) an ISceneNode)
ESNT_SCENE_MANAGER = MAKE_IRR_ID('s', 'm', 'n', 'g'),
//! Mesh Scene Node
ESNT_MESH = MAKE_IRR_ID('m', 'e', 's', 'h'),
//! Empty Scene Node
ESNT_EMPTY = MAKE_IRR_ID('e', 'm', 't', 'y'),
//! Dummy Transformation Scene Node
ESNT_DUMMY_TRANSFORMATION = MAKE_IRR_ID('d', 'm', 'm', 'y'),
//! Camera Scene Node
ESNT_CAMERA = MAKE_IRR_ID('c', 'a', 'm', '_'),
//! Billboard Scene Node
ESNT_BILLBOARD = MAKE_IRR_ID('b', 'i', 'l', 'l'),
//! Animated Mesh Scene Node
ESNT_ANIMATED_MESH = MAKE_IRR_ID('a', 'm', 's', 'h'),
//! Unknown scene node
ESNT_UNKNOWN = MAKE_IRR_ID('u', 'n', 'k', 'n'),
//! Will match with any scene node when checking types
ESNT_ANY = MAKE_IRR_ID('a', 'n', 'y', '_')
};
} // end namespace scene
} // end namespace irr

85
irr/include/EShaderTypes.h Normal file
View File

@ -0,0 +1,85 @@
#pragma once
#include "irrTypes.h"
namespace irr
{
namespace video
{
//! Compile target enumeration for the addHighLevelShaderMaterial() method.
enum E_VERTEX_SHADER_TYPE
{
EVST_VS_1_1 = 0,
EVST_VS_2_0,
EVST_VS_2_a,
EVST_VS_3_0,
EVST_VS_4_0,
EVST_VS_4_1,
EVST_VS_5_0,
//! This is not a type, but a value indicating how much types there are.
EVST_COUNT
};
//! Names for all vertex shader types, each entry corresponds to a E_VERTEX_SHADER_TYPE entry.
const c8 *const VERTEX_SHADER_TYPE_NAMES[] = {
"vs_1_1",
"vs_2_0",
"vs_2_a",
"vs_3_0",
"vs_4_0",
"vs_4_1",
"vs_5_0",
0};
//! Compile target enumeration for the addHighLevelShaderMaterial() method.
enum E_PIXEL_SHADER_TYPE
{
EPST_PS_1_1 = 0,
EPST_PS_1_2,
EPST_PS_1_3,
EPST_PS_1_4,
EPST_PS_2_0,
EPST_PS_2_a,
EPST_PS_2_b,
EPST_PS_3_0,
EPST_PS_4_0,
EPST_PS_4_1,
EPST_PS_5_0,
//! This is not a type, but a value indicating how much types there are.
EPST_COUNT
};
//! Names for all pixel shader types, each entry corresponds to a E_PIXEL_SHADER_TYPE entry.
const c8 *const PIXEL_SHADER_TYPE_NAMES[] = {
"ps_1_1",
"ps_1_2",
"ps_1_3",
"ps_1_4",
"ps_2_0",
"ps_2_a",
"ps_2_b",
"ps_3_0",
"ps_4_0",
"ps_4_1",
"ps_5_0",
0};
//! Enum for supported geometry shader types
enum E_GEOMETRY_SHADER_TYPE
{
EGST_GS_4_0 = 0,
//! This is not a type, but a value indicating how much types there are.
EGST_COUNT
};
//! String names for supported geometry shader types
const c8 *const GEOMETRY_SHADER_TYPE_NAMES[] = {
"gs_4_0",
0};
} // end namespace video
} // end namespace irr

34
irr/include/EVertexAttributes.h Normal file
View File

@ -0,0 +1,34 @@
#pragma once
namespace irr
{
namespace video
{
//! Enumeration for all vertex attributes there are.
enum E_VERTEX_ATTRIBUTES
{
EVA_POSITION = 0,
EVA_NORMAL,
EVA_COLOR,
EVA_TCOORD0,
EVA_TCOORD1,
EVA_TANGENT,
EVA_BINORMAL,
EVA_COUNT
};
//! Array holding the built in vertex attribute names
const char *const sBuiltInVertexAttributeNames[] = {
"inVertexPosition",
"inVertexNormal",
"inVertexColor",
"inTexCoord0",
"inTexCoord1",
"inVertexTangent",
"inVertexBinormal",
0,
};
} // end namespace video
} // end namespace irr

69
irr/include/IAnimatedMesh.h Normal file
View File

@ -0,0 +1,69 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "aabbox3d.h"
#include "IMesh.h"
namespace irr
{
namespace scene
{
//! Interface for an animated mesh.
/** There are already simple implementations of this interface available so
you don't have to implement this interface on your own if you need to:
You might want to use irr::scene::SAnimatedMesh, irr::scene::SMesh,
irr::scene::SMeshBuffer etc. */
class IAnimatedMesh : public IMesh
{
public:
//! Gets the frame count of the animated mesh.
/** Note that the play-time is usually getFrameCount()-1 as it stops as soon as the last frame-key is reached.
\return The amount of frames. If the amount is 1,
it is a static, non animated mesh. */
virtual u32 getFrameCount() const = 0;
//! Gets the animation speed of the animated mesh.
/** \return The number of frames per second to play the
animation with by default. If the amount is 0,
it is a static, non animated mesh. */
virtual f32 getAnimationSpeed() const = 0;
//! Sets the animation speed of the animated mesh.
/** \param fps Number of frames per second to play the
animation with by default. If the amount is 0,
it is not animated. The actual speed is set in the
scene node the mesh is instantiated in.*/
virtual void setAnimationSpeed(f32 fps) = 0;
//! Returns the IMesh interface for a frame.
/** \param frame: Frame number as zero based index. The maximum
frame number is getFrameCount() - 1;
\param detailLevel: Level of detail. 0 is the lowest, 255 the
highest level of detail. Most meshes will ignore the detail level.
\param startFrameLoop: Because some animated meshes (.MD2) are
blended between 2 static frames, and maybe animated in a loop,
the startFrameLoop and the endFrameLoop have to be defined, to
prevent the animation to be blended between frames which are
outside of this loop.
If startFrameLoop and endFrameLoop are both -1, they are ignored.
\param endFrameLoop: see startFrameLoop.
\return Returns the animated mesh based on a detail level. */
virtual IMesh *getMesh(s32 frame, s32 detailLevel = 255, s32 startFrameLoop = -1, s32 endFrameLoop = -1) = 0;
//! Returns the type of the animated mesh.
/** In most cases it is not necessary to use this method.
This is useful for making a safe downcast. For example,
if getMeshType() returns EAMT_MD2 it's safe to cast the
IAnimatedMesh to IAnimatedMeshMD2.
\returns Type of the mesh. */
E_ANIMATED_MESH_TYPE getMeshType() const override
{
return EAMT_UNKNOWN;
}
};
} // end namespace scene
} // end namespace irr

169
irr/include/IAnimatedMeshSceneNode.h Normal file
View File

@ -0,0 +1,169 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "ISceneNode.h"
#include "IBoneSceneNode.h"
#include "IAnimatedMesh.h"
namespace irr
{
namespace scene
{
enum E_JOINT_UPDATE_ON_RENDER
{
//! do nothing
EJUOR_NONE = 0,
//! get joints positions from the mesh (for attached nodes, etc)
EJUOR_READ,
//! control joint positions in the mesh (eg. ragdolls, or set the animation from animateJoints() )
EJUOR_CONTROL
};
class IAnimatedMeshSceneNode;
//! Callback interface for catching events of ended animations.
/** Implement this interface and use
IAnimatedMeshSceneNode::setAnimationEndCallback to be able to
be notified if an animation playback has ended.
**/
class IAnimationEndCallBack : public virtual IReferenceCounted
{
public:
//! Will be called when the animation playback has ended.
/** See IAnimatedMeshSceneNode::setAnimationEndCallback for
more information.
\param node: Node of which the animation has ended. */
virtual void OnAnimationEnd(IAnimatedMeshSceneNode *node) = 0;
};
//! Scene node capable of displaying an animated mesh.
class IAnimatedMeshSceneNode : public ISceneNode
{
public:
//! Constructor
IAnimatedMeshSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id,
const core::vector3df &position = core::vector3df(0, 0, 0),
const core::vector3df &rotation = core::vector3df(0, 0, 0),
const core::vector3df &scale = core::vector3df(1.0f, 1.0f, 1.0f)) :
ISceneNode(parent, mgr, id, position, rotation, scale) {}
//! Destructor
virtual ~IAnimatedMeshSceneNode() {}
//! Sets the current frame number.
/** From now on the animation is played from this frame.
\param frame: Number of the frame to let the animation be started from.
The frame number must be a valid frame number of the IMesh used by this
scene node. Set IAnimatedMesh::getMesh() for details. */
virtual void setCurrentFrame(f32 frame) = 0;
//! Sets the frame numbers between the animation is looped.
/** The default is 0 to getFrameCount()-1 of the mesh.
Number of played frames is end-start.
It interpolates toward the last frame but stops when it is reached.
It does not interpolate back to start even when looping.
Looping animations should ensure last and first frame-key are identical.
\param begin: Start frame number of the loop.
\param end: End frame number of the loop.
\return True if successful, false if not. */
virtual bool setFrameLoop(s32 begin, s32 end) = 0;
//! Sets the speed with which the animation is played.
/** \param framesPerSecond: Frames per second played. */
virtual void setAnimationSpeed(f32 framesPerSecond) = 0;
//! Gets the speed with which the animation is played.
/** \return Frames per second played. */
virtual f32 getAnimationSpeed() const = 0;
//! Get a pointer to a joint in the mesh (if the mesh is a bone based mesh).
/** With this method it is possible to attach scene nodes to
joints for example possible to attach a weapon to the left hand
of an animated model. This example shows how:
\code
ISceneNode* hand =
yourAnimatedMeshSceneNode->getJointNode("LeftHand");
hand->addChild(weaponSceneNode);
\endcode
Please note that the joint returned by this method may not exist
before this call and the joints in the node were created by it.
\param jointName: Name of the joint.
\return Pointer to the scene node which represents the joint
with the specified name. Returns 0 if the contained mesh is not
an skinned mesh or the name of the joint could not be found. */
virtual IBoneSceneNode *getJointNode(const c8 *jointName) = 0;
//! same as getJointNode(const c8* jointName), but based on id
virtual IBoneSceneNode *getJointNode(u32 jointID) = 0;
//! Gets joint count.
/** \return Amount of joints in the mesh. */
virtual u32 getJointCount() const = 0;
//! Returns the currently displayed frame number.
virtual f32 getFrameNr() const = 0;
//! Returns the current start frame number.
virtual s32 getStartFrame() const = 0;
//! Returns the current end frame number.
virtual s32 getEndFrame() const = 0;
//! Sets looping mode which is on by default.
/** If set to false, animations will not be played looped. */
virtual void setLoopMode(bool playAnimationLooped) = 0;
//! returns the current loop mode
/** When true the animations are played looped */
virtual bool getLoopMode() const = 0;
//! Sets a callback interface which will be called if an animation playback has ended.
/** Set this to 0 to disable the callback again.
Please note that this will only be called when in non looped
mode, see IAnimatedMeshSceneNode::setLoopMode(). */
virtual void setAnimationEndCallback(IAnimationEndCallBack *callback = 0) = 0;
//! Sets if the scene node should not copy the materials of the mesh but use them in a read only style.
/** In this way it is possible to change the materials a mesh
causing all mesh scene nodes referencing this mesh to change
too. */
virtual void setReadOnlyMaterials(bool readonly) = 0;
//! Returns if the scene node should not copy the materials of the mesh but use them in a read only style
virtual bool isReadOnlyMaterials() const = 0;
//! Sets a new mesh
virtual void setMesh(IAnimatedMesh *mesh) = 0;
//! Returns the current mesh
virtual IAnimatedMesh *getMesh(void) = 0;
//! Set how the joints should be updated on render
virtual void setJointMode(E_JOINT_UPDATE_ON_RENDER mode) = 0;
//! Sets the transition time in seconds
/** Note: This needs to enable joints, and setJointmode set to
EJUOR_CONTROL. You must call animateJoints(), or the mesh will
not animate. */
virtual void setTransitionTime(f32 Time) = 0;
//! animates the joints in the mesh based on the current frame.
/** Also takes in to account transitions. */
virtual void animateJoints(bool CalculateAbsolutePositions = true) = 0;
//! render mesh ignoring its transformation.
/** Culling is unaffected. */
virtual void setRenderFromIdentity(bool On) = 0;
//! Creates a clone of this scene node and its children.
/** \param newParent An optional new parent.
\param newManager An optional new scene manager.
\return The newly created clone of this node. */
virtual ISceneNode *clone(ISceneNode *newParent = 0, ISceneManager *newManager = 0) = 0;
};
} // end namespace scene
} // end namespace irr

125
irr/include/IAttributes.h Normal file
View File

@ -0,0 +1,125 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "EAttributes.h"
// not needed here but I can't be bothered to clean the transitive includes up.
#include "quaternion.h"
namespace irr
{
namespace video
{
class ITexture;
} // end namespace video
namespace io
{
//! Provides a generic interface for attributes and their values and the possibility to serialize them
class IAttributes : public virtual IReferenceCounted
{
public:
//! Returns amount of attributes in this collection of attributes.
virtual u32 getAttributeCount() const = 0;
//! Returns attribute name by index.
//! \param index: Index value, must be between 0 and getAttributeCount()-1.
virtual const c8 *getAttributeName(s32 index) const = 0;
//! Returns the type of an attribute
//! \param attributeName: Name for the attribute
virtual E_ATTRIBUTE_TYPE getAttributeType(const c8 *attributeName) const = 0;
//! Returns attribute type by index.
//! \param index: Index value, must be between 0 and getAttributeCount()-1.
virtual E_ATTRIBUTE_TYPE getAttributeType(s32 index) const = 0;
//! Returns if an attribute with a name exists
virtual bool existsAttribute(const c8 *attributeName) const = 0;
//! Returns attribute index from name, -1 if not found
virtual s32 findAttribute(const c8 *attributeName) const = 0;
//! Removes all attributes
virtual void clear() = 0;
/*
Integer Attribute
*/
//! Adds an attribute as integer
virtual void addInt(const c8 *attributeName, s32 value) = 0;
//! Sets an attribute as integer value
virtual void setAttribute(const c8 *attributeName, s32 value) = 0;
//! Gets an attribute as integer value
//! \param attributeName: Name of the attribute to get.
//! \param defaultNotFound Value returned when attributeName was not found
//! \return Returns value of the attribute previously set by setAttribute()
virtual s32 getAttributeAsInt(const c8 *attributeName, irr::s32 defaultNotFound = 0) const = 0;
//! Gets an attribute as integer value
//! \param index: Index value, must be between 0 and getAttributeCount()-1.
virtual s32 getAttributeAsInt(s32 index) const = 0;
//! Sets an attribute as integer value
virtual void setAttribute(s32 index, s32 value) = 0;
/*
Float Attribute
*/
//! Adds an attribute as float
virtual void addFloat(const c8 *attributeName, f32 value) = 0;
//! Sets a attribute as float value
virtual void setAttribute(const c8 *attributeName, f32 value) = 0;
//! Gets an attribute as float value
//! \param attributeName: Name of the attribute to get.
//! \param defaultNotFound Value returned when attributeName was not found
//! \return Returns value of the attribute previously set by setAttribute()
virtual f32 getAttributeAsFloat(const c8 *attributeName, irr::f32 defaultNotFound = 0.f) const = 0;
//! Gets an attribute as float value
//! \param index: Index value, must be between 0 and getAttributeCount()-1.
virtual f32 getAttributeAsFloat(s32 index) const = 0;
//! Sets an attribute as float value
virtual void setAttribute(s32 index, f32 value) = 0;
/*
Bool Attribute
*/
//! Adds an attribute as bool
virtual void addBool(const c8 *attributeName, bool value) = 0;
//! Sets an attribute as boolean value
virtual void setAttribute(const c8 *attributeName, bool value) = 0;
//! Gets an attribute as boolean value
//! \param attributeName: Name of the attribute to get.
//! \param defaultNotFound Value returned when attributeName was not found
//! \return Returns value of the attribute previously set by setAttribute()
virtual bool getAttributeAsBool(const c8 *attributeName, bool defaultNotFound = false) const = 0;
//! Gets an attribute as boolean value
//! \param index: Index value, must be between 0 and getAttributeCount()-1.
virtual bool getAttributeAsBool(s32 index) const = 0;
//! Sets an attribute as boolean value
virtual void setAttribute(s32 index, bool value) = 0;
};
} // end namespace io
} // end namespace irr

90
irr/include/IBillboardSceneNode.h Normal file
View File

@ -0,0 +1,90 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "ISceneNode.h"
namespace irr
{
namespace scene
{
class ICameraSceneNode;
class IMeshBuffer;
//! A billboard scene node.
/** A billboard is like a 3d sprite: A 2d element,
which always looks to the camera. It is usually used for explosions, fire,
lensflares, particles and things like that.
*/
class IBillboardSceneNode : public ISceneNode
{
public:
//! Constructor
IBillboardSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id,
const core::vector3df &position = core::vector3df(0, 0, 0)) :
ISceneNode(parent, mgr, id, position) {}
//! Sets the size of the billboard, making it rectangular.
virtual void setSize(const core::dimension2d<f32> &size) = 0;
//! Sets the size of the billboard with independent widths of the bottom and top edges.
/** \param[in] height The height of the billboard.
\param[in] bottomEdgeWidth The width of the bottom edge of the billboard.
\param[in] topEdgeWidth The width of the top edge of the billboard.
*/
virtual void setSize(f32 height, f32 bottomEdgeWidth, f32 topEdgeWidth) = 0;
//! Returns the size of the billboard.
/** This will return the width of the bottom edge of the billboard.
Use getWidths() to retrieve the bottom and top edges independently.
\return Size of the billboard.
*/
virtual const core::dimension2d<f32> &getSize() const = 0;
//! Gets the size of the the billboard and handles independent top and bottom edge widths correctly.
/** \param[out] height The height of the billboard.
\param[out] bottomEdgeWidth The width of the bottom edge of the billboard.
\param[out] topEdgeWidth The width of the top edge of the billboard.
*/
virtual void getSize(f32 &height, f32 &bottomEdgeWidth, f32 &topEdgeWidth) const = 0;
//! Set the color of all vertices of the billboard
/** \param[in] overallColor Color to set */
virtual void setColor(const video::SColor &overallColor) = 0;
//! Set the color of the top and bottom vertices of the billboard
/** \param[in] topColor Color to set the top vertices
\param[in] bottomColor Color to set the bottom vertices */
virtual void setColor(const video::SColor &topColor,
const video::SColor &bottomColor) = 0;
//! Gets the color of the top and bottom vertices of the billboard
/** \param[out] topColor Stores the color of the top vertices
\param[out] bottomColor Stores the color of the bottom vertices */
virtual void getColor(video::SColor &topColor,
video::SColor &bottomColor) const = 0;
//! Get the real boundingbox used by the billboard, which can depend on the active camera.
/** The boundingbox returned will use absolute coordinates.
The billboard orients itself toward the camera and some only update in render().
So we don't know the real boundingboxes before that. Which would be too late for culling.
That is why the usual getBoundingBox will return a "safe" boundingbox which is guaranteed
to contain the billboard. While this function can return the real one. */
virtual const core::aabbox3d<f32> &getTransformedBillboardBoundingBox(const irr::scene::ICameraSceneNode *camera) = 0;
//! Get the amount of mesh buffers.
/** \return Amount of mesh buffers (IMeshBuffer) in this mesh. */
virtual u32 getMeshBufferCount() const = 0;
//! Get pointer to a mesh buffer.
/** NOTE: Positions and normals of this meshbuffers are re-calculated before rendering.
So this is mainly useful to access/modify the uv-coordinates.
\param nr: Zero based index of the mesh buffer.
\return Pointer to the mesh buffer or 0 if there is no such mesh buffer. */
virtual IMeshBuffer *getMeshBuffer(u32 nr) const = 0;
};
} // end namespace scene
} // end namespace irr

96
irr/include/IBoneSceneNode.h Normal file
View File

@ -0,0 +1,96 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "ISceneNode.h"
namespace irr
{
namespace scene
{
//! Enumeration for different bone animation modes
enum E_BONE_ANIMATION_MODE
{
//! The bone is usually animated, unless it's parent is not animated
EBAM_AUTOMATIC = 0,
//! The bone is animated by the skin, if it's parent is not animated then animation will resume from this bone onward
EBAM_ANIMATED,
//! The bone is not animated by the skin
EBAM_UNANIMATED,
//! Not an animation mode, just here to count the available modes
EBAM_COUNT
};
enum E_BONE_SKINNING_SPACE
{
//! local skinning, standard
EBSS_LOCAL = 0,
//! global skinning
EBSS_GLOBAL,
EBSS_COUNT
};
//! Names for bone animation modes
const c8 *const BoneAnimationModeNames[] = {
"automatic",
"animated",
"unanimated",
0,
};
//! Interface for bones used for skeletal animation.
/** Used with ISkinnedMesh and IAnimatedMeshSceneNode. */
class IBoneSceneNode : public ISceneNode
{
public:
IBoneSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id = -1) :
ISceneNode(parent, mgr, id), positionHint(-1), scaleHint(-1), rotationHint(-1) {}
//! Get the index of the bone
virtual u32 getBoneIndex() const = 0;
//! Sets the animation mode of the bone.
/** \return True if successful. (Unused) */
virtual bool setAnimationMode(E_BONE_ANIMATION_MODE mode) = 0;
//! Gets the current animation mode of the bone
virtual E_BONE_ANIMATION_MODE getAnimationMode() const = 0;
//! Get the axis aligned bounding box of this node
const core::aabbox3d<f32> &getBoundingBox() const override = 0;
//! Returns the relative transformation of the scene node.
// virtual core::matrix4 getRelativeTransformation() const = 0;
//! The animation method.
void OnAnimate(u32 timeMs) override = 0;
//! The render method.
/** Does nothing as bones are not visible. */
void render() override {}
//! How the relative transformation of the bone is used
virtual void setSkinningSpace(E_BONE_SKINNING_SPACE space) = 0;
//! How the relative transformation of the bone is used
virtual E_BONE_SKINNING_SPACE getSkinningSpace() const = 0;
//! Updates the absolute position based on the relative and the parents position
virtual void updateAbsolutePositionOfAllChildren() = 0;
s32 positionHint;
s32 scaleHint;
s32 rotationHint;
};
} // end namespace scene
} // end namespace irr

184
irr/include/ICameraSceneNode.h Normal file
View File

@ -0,0 +1,184 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "ISceneNode.h"
#include "IEventReceiver.h"
namespace irr
{
namespace scene
{
struct SViewFrustum;
//! Scene Node which is a (controllable) camera.
/** The whole scene will be rendered from the cameras point of view.
Because the ICameraSceneNode is a SceneNode, it can be attached to any
other scene node, and will follow its parents movement, rotation and so
on.
*/
class ICameraSceneNode : public ISceneNode, public IEventReceiver
{
public:
//! Constructor
ICameraSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id,
const core::vector3df &position = core::vector3df(0, 0, 0),
const core::vector3df &rotation = core::vector3df(0, 0, 0),
const core::vector3df &scale = core::vector3df(1.0f, 1.0f, 1.0f)) :
ISceneNode(parent, mgr, id, position, rotation, scale),
IsOrthogonal(false) {}
//! Sets the projection matrix of the camera.
/** The core::matrix4 class has some methods to build a
projection matrix. e.g:
core::matrix4::buildProjectionMatrixPerspectiveFovLH.
Note that the matrix will only stay as set by this method until
one of the following Methods are called: setNearValue,
setFarValue, setAspectRatio, setFOV.
NOTE: The frustum is not updated before render() is called
unless you explicitly call updateMatrices()
\param projection The new projection matrix of the camera.
\param isOrthogonal Set this to true if the matrix is an
orthogonal one (e.g. from matrix4::buildProjectionMatrixOrtho).
*/
virtual void setProjectionMatrix(const core::matrix4 &projection, bool isOrthogonal = false) = 0;
//! Gets the current projection matrix of the camera.
/** \return The current projection matrix of the camera. */
virtual const core::matrix4 &getProjectionMatrix() const = 0;
//! Gets the current view matrix of the camera.
/** \return The current view matrix of the camera. */
virtual const core::matrix4 &getViewMatrix() const = 0;
//! Sets a custom view matrix affector.
/** The matrix passed here, will be multiplied with the view
matrix when it gets updated. This allows for custom camera
setups like, for example, a reflection camera.
\param affector The affector matrix. */
virtual void setViewMatrixAffector(const core::matrix4 &affector) = 0;
//! Get the custom view matrix affector.
/** \return The affector matrix. */
virtual const core::matrix4 &getViewMatrixAffector() const = 0;
//! It is possible to send mouse and key events to the camera.
/** Most cameras may ignore this input, but camera scene nodes
which are created for example with
ISceneManager::addCameraSceneNodeMaya or
ISceneManager::addCameraSceneNodeFPS, may want to get
this input for changing their position, look at target or
whatever. */
bool OnEvent(const SEvent &event) override = 0;
//! Sets the look at target of the camera
/** If the camera's target and rotation are bound ( @see
bindTargetAndRotation() ) then calling this will also change
the camera's scene node rotation to match the target.
Note that setTarget uses the current absolute position
internally, so if you changed setPosition since last rendering you must
call updateAbsolutePosition before using this function.
\param pos Look at target of the camera, in world co-ordinates. */
virtual void setTarget(const core::vector3df &pos) = 0;
//! Sets the rotation of the node.
/** This only modifies the relative rotation of the node.
If the camera's target and rotation are bound ( @see
bindTargetAndRotation() ) then calling this will also change
the camera's target to match the rotation.
\param rotation New rotation of the node in degrees. */
void setRotation(const core::vector3df &rotation) override = 0;
//! Gets the current look at target of the camera
/** \return The current look at target of the camera, in world co-ordinates */
virtual const core::vector3df &getTarget() const = 0;
//! Sets the up vector of the camera.
/** \param pos: New upvector of the camera. */
virtual void setUpVector(const core::vector3df &pos) = 0;
//! Gets the up vector of the camera.
/** \return The up vector of the camera, in world space. */
virtual const core::vector3df &getUpVector() const = 0;
//! Gets the value of the near plane of the camera.
/** \return The value of the near plane of the camera. */
virtual f32 getNearValue() const = 0;
//! Gets the value of the far plane of the camera.
/** \return The value of the far plane of the camera. */
virtual f32 getFarValue() const = 0;
//! Gets the aspect ratio of the camera.
/** \return The aspect ratio of the camera. */
virtual f32 getAspectRatio() const = 0;
//! Gets the field of view of the camera.
/** \return The field of view of the camera in radians. */
virtual f32 getFOV() const = 0;
//! Sets the value of the near clipping plane. (default: 1.0f)
/** \param zn: New z near value. */
virtual void setNearValue(f32 zn) = 0;
//! Sets the value of the far clipping plane (default: 2000.0f)
/** \param zf: New z far value. */
virtual void setFarValue(f32 zf) = 0;
//! Sets the aspect ratio (default: 4.0f / 3.0f)
/** \param aspect: New aspect ratio. */
virtual void setAspectRatio(f32 aspect) = 0;
//! Sets the field of view (Default: PI / 2.5f)
/** \param fovy: New field of view in radians. */
virtual void setFOV(f32 fovy) = 0;
//! Get the view frustum.
/** \return The current view frustum. */
virtual const SViewFrustum *getViewFrustum() const = 0;
//! Disables or enables the camera to get key or mouse inputs.
/** If this is set to true, the camera will respond to key
inputs otherwise not. */
virtual void setInputReceiverEnabled(bool enabled) = 0;
//! Checks if the input receiver of the camera is currently enabled.
virtual bool isInputReceiverEnabled() const = 0;
//! Checks if a camera is orthogonal.
virtual bool isOrthogonal() const
{
return IsOrthogonal;
}
//! Binds the camera scene node's rotation to its target position and vice versa, or unbinds them.
/** When bound, calling setRotation() will update the camera's
target position to be along its +Z axis, and likewise calling
setTarget() will update its rotation so that its +Z axis will
point at the target point. FPS camera use this binding by
default; other cameras do not.
\param bound True to bind the camera's scene node rotation
and targeting, false to unbind them.
@see getTargetAndRotationBinding() */
virtual void bindTargetAndRotation(bool bound) = 0;
//! Updates the matrices without uploading them to the driver
virtual void updateMatrices() = 0;
//! Queries if the camera scene node's rotation and its target position are bound together.
/** @see bindTargetAndRotation() */
virtual bool getTargetAndRotationBinding(void) const = 0;
protected:
void cloneMembers(const ICameraSceneNode *toCopyFrom)
{
IsOrthogonal = toCopyFrom->IsOrthogonal;
}
bool IsOrthogonal;
};
} // end namespace scene
} // end namespace irr

59
irr/include/IContextManager.h Normal file
View File

@ -0,0 +1,59 @@
// Copyright (C) 2013-2015 Patryk Nadrowski
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "SExposedVideoData.h"
#include "SIrrCreationParameters.h"
#include <string>
namespace irr
{
namespace video
{
// For system specific window contexts (used for OpenGL)
class IContextManager : public virtual IReferenceCounted
{
public:
//! Initialize manager with device creation parameters and device window (passed as exposed video data)
virtual bool initialize(const SIrrlichtCreationParameters &params, const SExposedVideoData &data) = 0;
//! Terminate manager, any cleanup that is left over. Manager needs a new initialize to be usable again
virtual void terminate() = 0;
//! Create surface based on current window set
virtual bool generateSurface() = 0;
//! Destroy current surface
virtual void destroySurface() = 0;
//! Create context based on current surface
virtual bool generateContext() = 0;
//! Destroy current context
virtual void destroyContext() = 0;
//! Get current context
virtual const SExposedVideoData &getContext() const = 0;
//! Change render context, disable old and activate new defined by videoData
//\param restorePrimaryOnZero When true: restore original driver context when videoData is set to 0 values.
// When false: resets the context when videoData is set to 0 values.
/** This is mostly used internally by IVideoDriver::beginScene().
But if you want to switch threads which access your OpenGL driver you will have to
call this function as follows:
Old thread gives up context with: activateContext(irr::video::SExposedVideoData());
New thread takes over context with: activateContext(videoDriver->getExposedVideoData());
Note that only 1 thread at a time may access an OpenGL context. */
virtual bool activateContext(const SExposedVideoData &videoData, bool restorePrimaryOnZero = false) = 0;
//! Get the address of any OpenGL procedure (including core procedures).
virtual void *getProcAddress(const std::string &procName) = 0;
//! Swap buffers.
virtual bool swapBuffers() = 0;
};
} // end namespace video
} // end namespace irr

195
irr/include/ICursorControl.h Normal file
View File

@ -0,0 +1,195 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "position2d.h"
#include "rect.h"
namespace irr
{
namespace gui
{
class IGUISpriteBank;
//! Default icons for cursors
enum ECURSOR_ICON
{
// Following cursors might be system specific, or might use an Irrlicht icon-set. No guarantees so far.
ECI_NORMAL, // arrow
ECI_CROSS, // Crosshair
ECI_HAND, // Hand
ECI_HELP, // Arrow and question mark
ECI_IBEAM, // typical text-selection cursor
ECI_NO, // should not click icon
ECI_WAIT, // hourglass
ECI_SIZEALL, // arrow in all directions
ECI_SIZENESW, // resizes in direction north-east or south-west
ECI_SIZENWSE, // resizes in direction north-west or south-east
ECI_SIZENS, // resizes in direction north or south
ECI_SIZEWE, // resizes in direction west or east
ECI_UP, // up-arrow
// Implementer note: Should we add system specific cursors, which use guaranteed the system icons,
// then I would recommend using a naming scheme like ECI_W32_CROSS, ECI_X11_CROSSHAIR and adding those
// additionally.
ECI_COUNT // maximal of defined cursors. Note that higher values can be created at runtime
};
//! Names for ECURSOR_ICON
const c8 *const GUICursorIconNames[ECI_COUNT + 1] = {
"normal",
"cross",
"hand",
"help",
"ibeam",
"no",
"wait",
"sizeall",
"sizenesw",
"sizenwse",
"sizens",
"sizewe",
"sizeup",
0,
};
//! structure used to set sprites as cursors.
struct SCursorSprite
{
SCursorSprite() :
SpriteBank(0), SpriteId(-1)
{
}
SCursorSprite(gui::IGUISpriteBank *spriteBank, s32 spriteId, const core::position2d<s32> &hotspot = (core::position2d<s32>(0, 0))) :
SpriteBank(spriteBank), SpriteId(spriteId), HotSpot(hotspot)
{
}
IGUISpriteBank *SpriteBank;
s32 SpriteId;
core::position2d<s32> HotSpot;
};
//! platform specific behavior flags for the cursor
enum ECURSOR_PLATFORM_BEHAVIOR
{
//! default - no platform specific behavior
ECPB_NONE = 0,
//! On X11 try caching cursor updates as XQueryPointer calls can be expensive.
/** Update cursor positions only when the irrlicht timer has been updated or the timer is stopped.
This means you usually get one cursor update per device->run() which will be fine in most cases.
See this forum-thread for a more detailed explanation:
http://irrlicht.sourceforge.net/forum/viewtopic.php?f=7&t=45525
*/
ECPB_X11_CACHE_UPDATES = 1
};
//! Interface to manipulate the mouse cursor.
class ICursorControl : public virtual IReferenceCounted
{
public:
//! Changes the visible state of the mouse cursor.
/** \param visible: The new visible state. If true, the cursor will be visible,
if false, it will be invisible. */
virtual void setVisible(bool visible) = 0;
//! Returns if the cursor is currently visible.
/** \return True if the cursor flag is set to visible, false if not. */
virtual bool isVisible() const = 0;
//! Sets the new position of the cursor.
/** The position must be
between (0.0f, 0.0f) and (1.0f, 1.0f), where (0.0f, 0.0f) is
the top left corner and (1.0f, 1.0f) is the bottom right corner of the
render window.
\param pos New position of the cursor. */
virtual void setPosition(const core::position2d<f32> &pos) = 0;
//! Sets the new position of the cursor.
/** The position must be
between (0.0f, 0.0f) and (1.0f, 1.0f), where (0.0f, 0.0f) is
the top left corner and (1.0f, 1.0f) is the bottom right corner of the
render window.
\param x New x-coord of the cursor.
\param y New x-coord of the cursor. */
virtual void setPosition(f32 x, f32 y) = 0;
//! Sets the new position of the cursor.
/** \param pos: New position of the cursor. The coordinates are pixel units. */
virtual void setPosition(const core::position2d<s32> &pos) = 0;
//! Sets the new position of the cursor.
/** \param x New x-coord of the cursor. The coordinates are pixel units.
\param y New y-coord of the cursor. The coordinates are pixel units. */
virtual void setPosition(s32 x, s32 y) = 0;
//! Returns the current position of the mouse cursor.
/** \param updateCursor When true ask system/OS for current cursor position.
When false return the last known (buffered) position ( this is useful to
check what has become of a setPosition call with float numbers).
\return Returns the current position of the cursor. The returned position
is the position of the mouse cursor in pixel units. */
virtual const core::position2d<s32> &getPosition(bool updateCursor = true) = 0;
//! Returns the current position of the mouse cursor.
/** \param updateCursor When true ask system/OS for current cursor position.
When false return the last known (buffered) position (this is
useful to check what has become of a setPosition call with float numbers
and is often different from the values you passed in setPosition).
\return Returns the current position of the cursor. The returned position
is a value between (0.0f, 0.0f) and (1.0f, 1.0f), where (0.0f, 0.0f) is
the top left corner and (1.0f, 1.0f) is the bottom right corner of the
render window. */
virtual core::position2d<f32> getRelativePosition(bool updateCursor = true) = 0;
//! Sets an absolute reference rect for setting and retrieving the cursor position.
/** If this rect is set, the cursor position is not being calculated relative to
the rendering window but to this rect. You can set the rect pointer to 0 to disable
this feature again. This feature is useful when rendering into parts of foreign windows
for example in an editor.
\param rect: A pointer to an reference rectangle or 0 to disable the reference rectangle.*/
virtual void setReferenceRect(core::rect<s32> *rect = 0) = 0;
//! Internally fixes the mouse position, and reports relative mouse movement compared to the old position
/** Specific to SDL */
virtual void setRelativeMode(bool relative){};
//! Sets the active cursor icon
/** Setting cursor icons is so far only supported on Win32 and Linux */
virtual void setActiveIcon(ECURSOR_ICON iconId) {}
//! Gets the currently active icon
virtual ECURSOR_ICON getActiveIcon() const { return gui::ECI_NORMAL; }
//! Add a custom sprite as cursor icon.
/** \return Identification for the icon */
virtual ECURSOR_ICON addIcon(const gui::SCursorSprite &icon) { return gui::ECI_NORMAL; }
//! replace a cursor icon.
/** Changing cursor icons is so far only supported on Win32 and Linux
Note that this only changes the icons within your application, system cursors outside your
application will not be affected.
*/
virtual void changeIcon(ECURSOR_ICON iconId, const gui::SCursorSprite &sprite) {}
//! Return a system-specific size which is supported for cursors. Larger icons will fail, smaller icons might work.
virtual core::dimension2di getSupportedIconSize() const { return core::dimension2di(0, 0); }
//! Set platform specific behavior flags.
virtual void setPlatformBehavior(ECURSOR_PLATFORM_BEHAVIOR behavior) {}
//! Return platform specific behavior.
/** \return Behavior set by setPlatformBehavior or ECPB_NONE for platforms not implementing specific behaviors.
*/
virtual ECURSOR_PLATFORM_BEHAVIOR getPlatformBehavior() const { return ECPB_NONE; }
};
} // end namespace gui
} // end namespace irr

36
irr/include/IDummyTransformationSceneNode.h Normal file
View File

@ -0,0 +1,36 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "ISceneNode.h"
namespace irr
{
namespace scene
{
//! Dummy scene node for adding additional transformations to the scene graph.
/** This scene node does not render itself, and does not respond to set/getPosition,
set/getRotation and set/getScale. Its just a simple scene node that takes a
matrix as relative transformation, making it possible to insert any transformation
anywhere into the scene graph.
This scene node is for example used by the IAnimatedMeshSceneNode for emulating
joint scene nodes when playing skeletal animations.
*/
class IDummyTransformationSceneNode : public ISceneNode
{
public:
//! Constructor
IDummyTransformationSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id) :
ISceneNode(parent, mgr, id) {}
//! Returns a reference to the current relative transformation matrix.
/** This is the matrix, this scene node uses instead of scale, translation
and rotation. */
virtual core::matrix4 &getRelativeTransformationMatrix() = 0;
};
} // end namespace scene
} // end namespace irr

632
irr/include/IEventReceiver.h Normal file
View File

@ -0,0 +1,632 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "ILogger.h"
#include "Keycodes.h"
#include "irrString.h"
namespace irr
{
//! Enumeration for all event types there are.
enum EEVENT_TYPE
{
//! An event of the graphical user interface.
/** GUI events are created by the GUI environment or the GUI elements in response
to mouse or keyboard events. When a GUI element receives an event it will either
process it and return true, or pass the event to its parent. If an event is not absorbed
before it reaches the root element then it will then be passed to the user receiver. */
EET_GUI_EVENT = 0,
//! A mouse input event.
/** Mouse events are created by the device and passed to IrrlichtDevice::postEventFromUser
in response to mouse input received from the operating system.
Mouse events are first passed to the user receiver, then to the GUI environment and its elements,
then finally the input receiving scene manager where it is passed to the active camera.
*/
EET_MOUSE_INPUT_EVENT,
//! A key input event.
/** Like mouse events, keyboard events are created by the device and passed to
IrrlichtDevice::postEventFromUser. They take the same path as mouse events. */
EET_KEY_INPUT_EVENT,
//! A string input event.
/** This event is created when multiple characters are sent at a time (e.g. using an IME). */
EET_STRING_INPUT_EVENT,
//! A touch input event.
EET_TOUCH_INPUT_EVENT,
//! A accelerometer event.
EET_ACCELEROMETER_EVENT,
//! A gyroscope event.
EET_GYROSCOPE_EVENT,
//! A device motion event.
EET_DEVICE_MOTION_EVENT,
//! A joystick (joypad, gamepad) input event.
/** Joystick events are created by polling all connected joysticks once per
device run() and then passing the events to IrrlichtDevice::postEventFromUser.
They take the same path as mouse events.
Windows, SDL: Implemented.
Linux: Implemented, with POV hat issues.
MacOS / Other: Not yet implemented.
*/
EET_JOYSTICK_INPUT_EVENT,
//! A log event
/** Log events are only passed to the user receiver if there is one. If they are absorbed by the
user receiver then no text will be sent to the console. */
EET_LOG_TEXT_EVENT,
//! A user event with user data.
/** This is not used by Irrlicht and can be used to send user
specific data though the system. The Irrlicht 'window handle'
can be obtained from IrrlichtDevice::getExposedVideoData()
The usage and behavior depends on the operating system:
Windows: send a WM_USER message to the Irrlicht Window; the
wParam and lParam will be used to populate the
UserData1 and UserData2 members of the SUserEvent.
Linux: send a ClientMessage via XSendEvent to the Irrlicht
Window; the data.l[0] and data.l[1] members will be
cast to s32 and used as UserData1 and UserData2.
MacOS: Not yet implemented
*/
EET_USER_EVENT,
//! Pass on raw events from the OS
EET_SYSTEM_EVENT,
//! Application state events like a resume, pause etc.
EET_APPLICATION_EVENT,
//! This enum is never used, it only forces the compiler to
//! compile these enumeration values to 32 bit.
EGUIET_FORCE_32_BIT = 0x7fffffff
};
//! Enumeration for all mouse input events
enum EMOUSE_INPUT_EVENT
{
//! Left mouse button was pressed down.
EMIE_LMOUSE_PRESSED_DOWN = 0,
//! Right mouse button was pressed down.
EMIE_RMOUSE_PRESSED_DOWN,
//! Middle mouse button was pressed down.
EMIE_MMOUSE_PRESSED_DOWN,
//! Left mouse button was left up.
EMIE_LMOUSE_LEFT_UP,
//! Right mouse button was left up.
EMIE_RMOUSE_LEFT_UP,
//! Middle mouse button was left up.
EMIE_MMOUSE_LEFT_UP,
//! The mouse cursor changed its position.
EMIE_MOUSE_MOVED,
//! The mouse wheel was moved. Use Wheel value in event data to find out
//! in what direction and how fast.
EMIE_MOUSE_WHEEL,
//! Left mouse button double click.
//! This event is generated after the second EMIE_LMOUSE_PRESSED_DOWN event.
EMIE_LMOUSE_DOUBLE_CLICK,
//! Right mouse button double click.
//! This event is generated after the second EMIE_RMOUSE_PRESSED_DOWN event.
EMIE_RMOUSE_DOUBLE_CLICK,
//! Middle mouse button double click.
//! This event is generated after the second EMIE_MMOUSE_PRESSED_DOWN event.
EMIE_MMOUSE_DOUBLE_CLICK,
//! Left mouse button triple click.
//! This event is generated after the third EMIE_LMOUSE_PRESSED_DOWN event.
EMIE_LMOUSE_TRIPLE_CLICK,
//! Right mouse button triple click.
//! This event is generated after the third EMIE_RMOUSE_PRESSED_DOWN event.
EMIE_RMOUSE_TRIPLE_CLICK,
//! Middle mouse button triple click.
//! This event is generated after the third EMIE_MMOUSE_PRESSED_DOWN event.
EMIE_MMOUSE_TRIPLE_CLICK,
//! Mouse enters canvas used for rendering.
//! Only generated on emscripten
EMIE_MOUSE_ENTER_CANVAS,
//! Mouse leaves canvas used for rendering.
//! Only generated on emscripten
EMIE_MOUSE_LEAVE_CANVAS,
//! No real event. Just for convenience to get number of events
EMIE_COUNT
};
//! Masks for mouse button states
enum E_MOUSE_BUTTON_STATE_MASK
{
EMBSM_LEFT = 0x01,
EMBSM_RIGHT = 0x02,
EMBSM_MIDDLE = 0x04,
//! currently only on windows
EMBSM_EXTRA1 = 0x08,
//! currently only on windows
EMBSM_EXTRA2 = 0x10,
EMBSM_FORCE_32_BIT = 0x7fffffff
};
//! Enumeration for all touch input events
enum ETOUCH_INPUT_EVENT
{
//! Touch was pressed down.
ETIE_PRESSED_DOWN = 0,
//! Touch was left up.
ETIE_LEFT_UP,
//! The touch changed its position.
ETIE_MOVED,
//! No real event. Just for convenience to get number of events
ETIE_COUNT
};
enum ESYSTEM_EVENT_TYPE
{
//! From Android command handler for native activity messages
ESET_ANDROID_CMD = 0,
// TODO: for example ESET_WINDOWS_MESSAGE for win32 message loop events
//! No real event, but to get number of event types
ESET_COUNT
};
//! Enumeration for a commonly used application state events (it's useful mainly for mobile devices)
enum EAPPLICATION_EVENT_TYPE
{
//! The application will be resumed.
EAET_WILL_RESUME = 0,
//! The application has been resumed.
EAET_DID_RESUME,
//! The application will be paused.
EAET_WILL_PAUSE,
//! The application has been paused.
EAET_DID_PAUSE,
//! The application will be terminated.
EAET_WILL_TERMINATE,
//! The application received a memory warning.
EAET_MEMORY_WARNING,
//! No real event, but to get number of event types.
EAET_COUNT
};
namespace gui
{
class IGUIElement;
//! Enumeration for all events which are sendable by the gui system
enum EGUI_EVENT_TYPE
{
//! A gui element has lost its focus.
/** GUIEvent.Caller is losing the focus to GUIEvent.Element.
If the event is absorbed then the focus will not be changed. */
EGET_ELEMENT_FOCUS_LOST = 0,
//! A gui element has got the focus.
/** If the event is absorbed then the focus will not be changed. */
EGET_ELEMENT_FOCUSED,
//! The mouse cursor hovered over a gui element.
/** If an element has sub-elements you also get this message for the subelements */
EGET_ELEMENT_HOVERED,
//! The mouse cursor left the hovered element.
/** If an element has sub-elements you also get this message for the subelements */
EGET_ELEMENT_LEFT,
//! An element would like to close.
/** Windows and context menus use this event when they would like to close,
this can be canceled by absorbing the event. */
EGET_ELEMENT_CLOSED,
//! A button was clicked.
EGET_BUTTON_CLICKED,
//! A scrollbar has changed its position.
EGET_SCROLL_BAR_CHANGED,
//! A checkbox has changed its check state.
EGET_CHECKBOX_CHANGED,
//! A listbox would like to open.
/** You can prevent the listbox from opening by absorbing the event. */
EGET_LISTBOX_OPENED,
//! A new item in a listbox was selected.
/** NOTE: You also get this event currently when the same item was clicked again after more than 500 ms. */
EGET_LISTBOX_CHANGED,
//! An item in the listbox was selected, which was already selected.
/** NOTE: You get the event currently only if the item was clicked again within 500 ms or selected by "enter" or "space". */
EGET_LISTBOX_SELECTED_AGAIN,
//! A file has been selected in the file dialog
EGET_FILE_SELECTED,
//! A directory has been selected in the file dialog
EGET_DIRECTORY_SELECTED,
//! A file open dialog has been closed without choosing a file
EGET_FILE_CHOOSE_DIALOG_CANCELLED,
//! In an editbox 'ENTER' was pressed
EGET_EDITBOX_ENTER,
//! The text in an editbox was changed. This does not include automatic changes in text-breaking.
EGET_EDITBOX_CHANGED,
//! The marked area in an editbox was changed.
EGET_EDITBOX_MARKING_CHANGED,
//! The tab was changed in an tab control
EGET_TAB_CHANGED,
//! The selection in a combo box has been changed
EGET_COMBO_BOX_CHANGED,
//! A table has changed
EGET_TABLE_CHANGED,
EGET_TABLE_HEADER_CHANGED,
EGET_TABLE_SELECTED_AGAIN,
//! No real event. Just for convenience to get number of events
EGET_COUNT
};
} // end namespace gui
//! SEvents hold information about an event. See irr::IEventReceiver for details on event handling.
struct SEvent
{
//! Any kind of GUI event.
struct SGUIEvent
{
//! IGUIElement who called the event
gui::IGUIElement *Caller;
//! If the event has something to do with another element, it will be held here.
gui::IGUIElement *Element;
//! Type of GUI Event
gui::EGUI_EVENT_TYPE EventType;
};
//! Any kind of mouse event.
struct SMouseInput
{
//! X position of mouse cursor
s32 X;
//! Y position of mouse cursor
s32 Y;
//! mouse wheel delta, often 1.0 or -1.0, but can have other values < 0.f or > 0.f;
/** Only valid if event was EMIE_MOUSE_WHEEL */
f32 Wheel;
//! True if shift was also pressed
bool Shift : 1;
//! True if ctrl was also pressed
bool Control : 1;
//! A bitmap of button states. You can use isButtonPressed() to determine
//! if a button is pressed or not.
//! Currently only valid if the event was EMIE_MOUSE_MOVED
u32 ButtonStates;
//! Is the left button pressed down?
bool isLeftPressed() const { return 0 != (ButtonStates & EMBSM_LEFT); }
//! Is the right button pressed down?
bool isRightPressed() const { return 0 != (ButtonStates & EMBSM_RIGHT); }
//! Is the middle button pressed down?
bool isMiddlePressed() const { return 0 != (ButtonStates & EMBSM_MIDDLE); }
//! Type of mouse event
EMOUSE_INPUT_EVENT Event;
};
//! Any kind of keyboard event.
struct SKeyInput
{
//! Character corresponding to the key (0, if not a character, value undefined in key releases)
wchar_t Char;
//! Key which has been pressed or released
EKEY_CODE Key;
//! System dependent code. Only set for systems which are described below, otherwise undefined.
//! Android: int32_t with physical key as returned by AKeyEvent_getKeyCode
u32 SystemKeyCode;
//! If not true, then the key was left up
bool PressedDown : 1;
//! True if shift was also pressed
bool Shift : 1;
//! True if ctrl was also pressed
bool Control : 1;
};
//! String input event.
struct SStringInput
{
//! The string that is entered
core::stringw *Str;
};
//! Any kind of touch event.
struct STouchInput
{
// Touch ID.
size_t ID;
// X position of simple touch.
s32 X;
// Y position of simple touch.
s32 Y;
// number of current touches
s32 touchedCount;
//! Type of touch event.
ETOUCH_INPUT_EVENT Event;
};
//! Any kind of accelerometer event.
struct SAccelerometerEvent
{
// X acceleration.
f64 X;
// Y acceleration.
f64 Y;
// Z acceleration.
f64 Z;
};
//! Any kind of gyroscope event.
struct SGyroscopeEvent
{
// X rotation.
f64 X;
// Y rotation.
f64 Y;
// Z rotation.
f64 Z;
};
//! Any kind of device motion event.
struct SDeviceMotionEvent
{
// X angle - roll.
f64 X;
// Y angle - pitch.
f64 Y;
// Z angle - yaw.
f64 Z;
};
//! A joystick event.
/** Unlike other events, joystick events represent the result of polling
* each connected joystick once per run() of the device. Joystick events will
* not be generated by default. If joystick support is available for the
* active device, and @ref irr::IrrlichtDevice::activateJoysticks() has been
* called, an event of this type will be generated once per joystick per
* @ref IrrlichtDevice::run() regardless of whether the state of the joystick
* has actually changed. */
struct SJoystickEvent
{
enum
{
NUMBER_OF_BUTTONS = 32,
AXIS_X = 0, // e.g. analog stick 1 left to right
AXIS_Y, // e.g. analog stick 1 top to bottom
AXIS_Z, // e.g. throttle, or analog 2 stick 2 left to right
AXIS_R, // e.g. rudder, or analog 2 stick 2 top to bottom
AXIS_U,
AXIS_V,
NUMBER_OF_AXES = 18 // (please tell Irrlicht maintainers if you absolutely need more axes)
};
/** A bitmap of button states. You can use IsButtonPressed() to
( check the state of each button from 0 to (NUMBER_OF_BUTTONS - 1) */
u32 ButtonStates;
/** For AXIS_X, AXIS_Y, AXIS_Z, AXIS_R, AXIS_U and AXIS_V
* Values are in the range -32768 to 32767, with 0 representing
* the center position. You will receive the raw value from the
* joystick, and so will usually want to implement a dead zone around
* the center of the range. Axes not supported by this joystick will
* always have a value of 0. On Linux, POV hats are represented as axes,
* usually the last two active axis.
*/
s16 Axis[NUMBER_OF_AXES];
/** The POV represents the angle of the POV hat in degrees * 100,
* from 0 to 35,900. A value of 65535 indicates that the POV hat
* is centered (or not present).
* This value is only supported on Windows. On Linux, the POV hat
* will be sent as 2 axes instead. */
u16 POV;
//! The ID of the joystick which generated this event.
/** This is an internal Irrlicht index; it does not map directly
* to any particular hardware joystick. */
u8 Joystick;
//! A helper function to check if a button is pressed.
bool IsButtonPressed(u32 button) const
{
if (button >= (u32)NUMBER_OF_BUTTONS)
return false;
return (ButtonStates & (1 << button)) ? true : false;
}
};
//! Any kind of log event.
struct SLogEvent
{
//! Pointer to text which has been logged
const c8 *Text;
//! Log level in which the text has been logged
ELOG_LEVEL Level;
};
//! Any kind of user event.
struct SUserEvent
{
//! Some user specified data as int
size_t UserData1;
//! Another user specified data as int
size_t UserData2;
};
// Raw events from the OS
struct SSystemEvent
{
//! Android command handler native activity messages.
struct SAndroidCmd
{
//! APP_CMD_ enums defined in android_native_app_glue.h from the Android NDK
s32 Cmd;
};
// TOOD: more structs for iphone, Windows, X11, etc.
ESYSTEM_EVENT_TYPE EventType;
union
{
struct SAndroidCmd AndroidCmd;
};
};
// Application state event
struct SApplicationEvent
{
EAPPLICATION_EVENT_TYPE EventType;
};
EEVENT_TYPE EventType;
union
{
struct SGUIEvent GUIEvent;
struct SMouseInput MouseInput;
struct SKeyInput KeyInput;
struct SStringInput StringInput;
struct STouchInput TouchInput;
struct SAccelerometerEvent AccelerometerEvent;
struct SGyroscopeEvent GyroscopeEvent;
struct SDeviceMotionEvent DeviceMotionEvent;
struct SJoystickEvent JoystickEvent;
struct SLogEvent LogEvent;
struct SUserEvent UserEvent;
struct SSystemEvent SystemEvent;
struct SApplicationEvent ApplicationEvent;
};
};
//! Interface of an object which can receive events.
/** Many of the engine's classes inherit IEventReceiver so they are able to
process events. Events usually start at a postEventFromUser function and are
passed down through a chain of event receivers until OnEvent returns true. See
irr::EEVENT_TYPE for a description of where each type of event starts, and the
path it takes through the system. */
class IEventReceiver
{
public:
//! Destructor
virtual ~IEventReceiver() {}
//! Called if an event happened.
/** Please take care that you should only return 'true' when you want to _prevent_ Irrlicht
* from processing the event any further. So 'true' does mean that an event is completely done.
* Therefore your return value for all unprocessed events should be 'false'.
\return True if the event was processed.
*/
virtual bool OnEvent(const SEvent &event) = 0;
};
//! Information on a joystick, returned from @ref irr::IrrlichtDevice::activateJoysticks()
struct SJoystickInfo
{
//! The ID of the joystick
/** This is an internal Irrlicht index; it does not map directly
* to any particular hardware joystick. It corresponds to the
* irr::SJoystickEvent Joystick ID. */
u8 Joystick;
//! The name that the joystick uses to identify itself.
core::stringc Name;
//! The number of buttons that the joystick has.
u32 Buttons;
//! The number of axes that the joystick has, i.e. X, Y, Z, R, U, V.
/** Note: with a Linux device, the POV hat (if any) will use two axes. These
* will be included in this count. */
u32 Axes;
//! An indication of whether the joystick has a POV hat.
/** A Windows device will identify the presence or absence of the POV hat.
* A Linux device cannot, and will always return POV_HAT_UNKNOWN. */
enum
{
//! A hat is definitely present.
POV_HAT_PRESENT,
//! A hat is definitely not present.
POV_HAT_ABSENT,
//! The presence or absence of a hat cannot be determined.
POV_HAT_UNKNOWN
} PovHat;
}; // struct SJoystickInfo
} // end namespace irr

127
irr/include/IFileArchive.h Normal file
View File

@ -0,0 +1,127 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt/ Thomas Alten
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReadFile.h"
#include "IFileList.h"
namespace irr
{
namespace io
{
//! FileSystemType: which filesystem should be used for e.g. browsing
enum EFileSystemType
{
FILESYSTEM_NATIVE = 0, // Native OS FileSystem
FILESYSTEM_VIRTUAL // Virtual FileSystem
};
//! Contains the different types of archives
enum E_FILE_ARCHIVE_TYPE
{
//! A PKZIP archive
EFAT_ZIP = MAKE_IRR_ID('Z', 'I', 'P', 0),
//! A gzip archive
EFAT_GZIP = MAKE_IRR_ID('g', 'z', 'i', 'p'),
//! An Android asset file archive
EFAT_ANDROID_ASSET = MAKE_IRR_ID('A', 'S', 'S', 'E'),
//! The type of this archive is unknown
EFAT_UNKNOWN = MAKE_IRR_ID('u', 'n', 'k', 'n')
};
//! The FileArchive manages archives and provides access to files inside them.
class IFileArchive : public virtual IReferenceCounted
{
public:
//! Opens a file based on its name
/** Creates and returns a new IReadFile for a file in the archive.
\param filename The file to open
\return Returns A pointer to the created file on success,
or 0 on failure. */
virtual IReadFile *createAndOpenFile(const path &filename) = 0;
//! Opens a file based on its position in the file list.
/** Creates and returns
\param index The zero based index of the file.
\return Returns a pointer to the created file on success, or 0 on failure. */
virtual IReadFile *createAndOpenFile(u32 index) = 0;
//! Returns the complete file tree
/** \return Returns the complete directory tree for the archive,
including all files and folders */
virtual const IFileList *getFileList() const = 0;
//! get the archive type
virtual E_FILE_ARCHIVE_TYPE getType() const { return EFAT_UNKNOWN; }
//! return the name (id) of the file Archive
virtual const io::path &getArchiveName() const = 0;
//! Add a directory in the archive and all it's files to the FileList
/** Only needed for file-archives which have no information about their own
directory structure. In that case the user must add directories manually.
Currently this is necessary for archives of type EFAT_ANDROID_ASSET.
The root-path itself is already set by the engine.
If directories are not added manually opening files might still work,
but checks if file exists will fail.
*/
virtual void addDirectoryToFileList(const io::path &filename) {}
//! An optionally used password string
/** This variable is publicly accessible from the interface in order to
avoid single access patterns to this place, and hence allow some more
obscurity.
*/
core::stringc Password;
};
//! Class which is able to create an archive from a file.
/** If you want the Irrlicht Engine be able to load archives of
currently unsupported file formats (e.g .wad), then implement
this and add your new Archive loader with
IFileSystem::addArchiveLoader() to the engine. */
class IArchiveLoader : public virtual IReferenceCounted
{
public:
//! Check if the file might be loaded by this class
/** Check based on the file extension (e.g. ".zip")
\param filename Name of file to check.
\return True if file seems to be loadable. */
virtual bool isALoadableFileFormat(const path &filename) const = 0;
//! Check if the file might be loaded by this class
/** This check may look into the file.
\param file File handle to check.
\return True if file seems to be loadable. */
virtual bool isALoadableFileFormat(io::IReadFile *file) const = 0;
//! Check to see if the loader can create archives of this type.
/** Check based on the archive type.
\param fileType The archive type to check.
\return True if the archive loader supports this type, false if not */
virtual bool isALoadableFileFormat(E_FILE_ARCHIVE_TYPE fileType) const = 0;
//! Creates an archive from the filename
/** \param filename File to use.
\param ignoreCase Searching is performed without regarding the case
\param ignorePaths Files are searched for without checking for the directories
\return Pointer to newly created archive, or 0 upon error. */
virtual IFileArchive *createArchive(const path &filename, bool ignoreCase, bool ignorePaths) const = 0;
//! Creates an archive from the file
/** \param file File handle to use.
\param ignoreCase Searching is performed without regarding the case
\param ignorePaths Files are searched for without checking for the directories
\return Pointer to newly created archive, or 0 upon error. */
virtual IFileArchive *createArchive(io::IReadFile *file, bool ignoreCase, bool ignorePaths) const = 0;
};
} // end namespace io
} // end namespace irr

89
irr/include/IFileList.h Normal file
View File

@ -0,0 +1,89 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "path.h"
namespace irr
{
namespace io
{
//! Provides a list of files and folders.
/** File lists usually contain a list of all files in a given folder,
but can also contain a complete directory structure. */
class IFileList : public virtual IReferenceCounted
{
public:
//! Get the number of files in the filelist.
/** \return Amount of files and directories in the file list. */
virtual u32 getFileCount() const = 0;
//! Gets the name of a file in the list, based on an index.
/** The path is not included in this name. Use getFullFileName for this.
\param index is the zero based index of the file which name should
be returned. The index must be less than the amount getFileCount() returns.
\return File name of the file. Returns 0, if an error occurred. */
virtual const io::path &getFileName(u32 index) const = 0;
//! Gets the full name of a file in the list including the path, based on an index.
/** \param index is the zero based index of the file which name should
be returned. The index must be less than the amount getFileCount() returns.
\return File name of the file. Returns 0 if an error occurred. */
virtual const io::path &getFullFileName(u32 index) const = 0;
//! Returns the size of a file in the file list, based on an index.
/** \param index is the zero based index of the file which should be returned.
The index must be less than the amount getFileCount() returns.
\return The size of the file in bytes. */
virtual u32 getFileSize(u32 index) const = 0;
//! Returns the file offset of a file in the file list, based on an index.
/** \param index is the zero based index of the file which should be returned.
The index must be less than the amount getFileCount() returns.
\return The offset of the file in bytes. */
virtual u32 getFileOffset(u32 index) const = 0;
//! Returns the ID of a file in the file list, based on an index.
/** This optional ID can be used to link the file list entry to information held
elsewhere. For example this could be an index in an IFileArchive, linking the entry
to its data offset, uncompressed size and CRC.
\param index is the zero based index of the file which should be returned.
The index must be less than the amount getFileCount() returns.
\return The ID of the file. */
virtual u32 getID(u32 index) const = 0;
//! Check if the file is a directory
/** \param index The zero based index which will be checked. The index
must be less than the amount getFileCount() returns.
\return True if the file is a directory, else false. */
virtual bool isDirectory(u32 index) const = 0;
//! Searches for a file or folder in the list
/** Searches for a file by name
\param filename The name of the file to search for.
\param isFolder True if you are searching for a directory path, false if you are searching for a file
\return Returns the index of the file in the file list, or -1 if
no matching name name was found. */
virtual s32 findFile(const io::path &filename, bool isFolder = false) const = 0;
//! Returns the base path of the file list
virtual const io::path &getPath() const = 0;
//! Add as a file or folder to the list
/** \param fullPath The file name including path, from the root of the file list.
\param isDirectory True if this is a directory rather than a file.
\param offset The file offset inside an archive
\param size The size of the file in bytes.
\param id The ID of the file in the archive which owns it */
virtual u32 addItem(const io::path &fullPath, u32 offset, u32 size, bool isDirectory, u32 id = 0) = 0;
//! Sorts the file list. You should call this after adding any items to the file list
virtual void sort() = 0;
};
} // end namespace irr
} // end namespace io

265
irr/include/IFileSystem.h Normal file
View File

@ -0,0 +1,265 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "IFileArchive.h"
namespace irr
{
namespace video
{
class IVideoDriver;
} // end namespace video
namespace io
{
class IReadFile;
class IWriteFile;
class IFileList;
class IAttributes;
//! The FileSystem manages files and archives and provides access to them.
/** It manages where files are, so that modules which use the the IO do not
need to know where every file is located. A file could be in a .zip-Archive or
as file on disk, using the IFileSystem makes no difference to this. */
class IFileSystem : public virtual IReferenceCounted
{
public:
//! Opens a file for read access.
/** \param filename: Name of file to open.
\return Pointer to the created file interface.
The returned pointer should be dropped when no longer needed.
See IReferenceCounted::drop() for more information. */
virtual IReadFile *createAndOpenFile(const path &filename) = 0;
//! Creates an IReadFile interface for accessing memory like a file.
/** This allows you to use a pointer to memory where an IReadFile is requested.
\param memory: A pointer to the start of the file in memory
\param len: The length of the memory in bytes
\param fileName: The name given to this file
\param deleteMemoryWhenDropped: True if the memory should be deleted
along with the IReadFile when it is dropped.
\return Pointer to the created file interface.
The returned pointer should be dropped when no longer needed.
See IReferenceCounted::drop() for more information.
*/
virtual IReadFile *createMemoryReadFile(const void *memory, s32 len, const path &fileName, bool deleteMemoryWhenDropped = false) = 0;
//! Creates an IReadFile interface for accessing files inside files.
/** This is useful e.g. for archives.
\param fileName: The name given to this file
\param alreadyOpenedFile: Pointer to the enclosing file
\param pos: Start of the file inside alreadyOpenedFile
\param areaSize: The length of the file
\return A pointer to the created file interface.
The returned pointer should be dropped when no longer needed.
See IReferenceCounted::drop() for more information.
*/
virtual IReadFile *createLimitReadFile(const path &fileName,
IReadFile *alreadyOpenedFile, long pos, long areaSize) = 0;
//! Creates an IWriteFile interface for accessing memory like a file.
/** This allows you to use a pointer to memory where an IWriteFile is requested.
You are responsible for allocating enough memory.
\param memory: A pointer to the start of the file in memory (allocated by you)
\param len: The length of the memory in bytes
\param fileName: The name given to this file
\param deleteMemoryWhenDropped: True if the memory should be deleted
along with the IWriteFile when it is dropped.
\return Pointer to the created file interface.
The returned pointer should be dropped when no longer needed.
See IReferenceCounted::drop() for more information.
*/
virtual IWriteFile *createMemoryWriteFile(void *memory, s32 len, const path &fileName, bool deleteMemoryWhenDropped = false) = 0;
//! Opens a file for write access.
/** \param filename: Name of file to open.
\param append: If the file already exist, all write operations are
appended to the file.
\return Pointer to the created file interface. 0 is returned, if the
file could not created or opened for writing.
The returned pointer should be dropped when no longer needed.
See IReferenceCounted::drop() for more information. */
virtual IWriteFile *createAndWriteFile(const path &filename, bool append = false) = 0;
//! Adds an archive to the file system.
/** After calling this, the Irrlicht Engine will also search and open
files directly from this archive. This is useful for hiding data from
the end user, speeding up file access and making it possible to access
for example Quake3 .pk3 files, which are just renamed .zip files. By
default Irrlicht supports ZIP, PAK, TAR, PNK, and directories as
archives. You can provide your own archive types by implementing
IArchiveLoader and passing an instance to addArchiveLoader.
Irrlicht supports AES-encrypted zip files, and the advanced compression
techniques lzma and bzip2.
\param filename: Filename of the archive to add to the file system.
\param ignoreCase: If set to true, files in the archive can be accessed without
writing all letters in the right case.
\param ignorePaths: If set to true, files in the added archive can be accessed
without its complete path.
\param archiveType: If no specific E_FILE_ARCHIVE_TYPE is selected then
the type of archive will depend on the extension of the file name. If
you use a different extension then you can use this parameter to force
a specific type of archive.
\param password An optional password, which is used in case of encrypted archives.
\param retArchive A pointer that will be set to the archive that is added.
\return True if the archive was added successfully, false if not. */
virtual bool addFileArchive(const path &filename, bool ignoreCase = true,
bool ignorePaths = true,
E_FILE_ARCHIVE_TYPE archiveType = EFAT_UNKNOWN,
const core::stringc &password = "",
IFileArchive **retArchive = 0) = 0;
//! Adds an archive to the file system.
/** After calling this, the Irrlicht Engine will also search and open
files directly from this archive. This is useful for hiding data from
the end user, speeding up file access and making it possible to access
for example Quake3 .pk3 files, which are just renamed .zip files. By
default Irrlicht supports ZIP, PAK, TAR, PNK, and directories as
archives. You can provide your own archive types by implementing
IArchiveLoader and passing an instance to addArchiveLoader.
Irrlicht supports AES-encrypted zip files, and the advanced compression
techniques lzma and bzip2.
If you want to add a directory as an archive, prefix its name with a
slash in order to let Irrlicht recognize it as a folder mount (mypath/).
Using this technique one can build up a search order, because archives
are read first, and can be used more easily with relative filenames.
\param file: Archive to add to the file system.
\param ignoreCase: If set to true, files in the archive can be accessed without
writing all letters in the right case.
\param ignorePaths: If set to true, files in the added archive can be accessed
without its complete path.
\param archiveType: If no specific E_FILE_ARCHIVE_TYPE is selected then
the type of archive will depend on the extension of the file name. If
you use a different extension then you can use this parameter to force
a specific type of archive.
\param password An optional password, which is used in case of encrypted archives.
\param retArchive A pointer that will be set to the archive that is added.
\return True if the archive was added successfully, false if not. */
virtual bool addFileArchive(IReadFile *file, bool ignoreCase = true,
bool ignorePaths = true,
E_FILE_ARCHIVE_TYPE archiveType = EFAT_UNKNOWN,
const core::stringc &password = "",
IFileArchive **retArchive = 0) = 0;
//! Adds an archive to the file system.
/** \param archive: The archive to add to the file system.
\return True if the archive was added successfully, false if not. */
virtual bool addFileArchive(IFileArchive *archive) = 0;
//! Get the number of archives currently attached to the file system
virtual u32 getFileArchiveCount() const = 0;
//! Removes an archive from the file system.
/** This will close the archive and free any file handles, but will not
close resources which have already been loaded and are now cached, for
example textures and meshes.
\param index: The index of the archive to remove
\return True on success, false on failure */
virtual bool removeFileArchive(u32 index) = 0;
//! Removes an archive from the file system.
/** This will close the archive and free any file handles, but will not
close resources which have already been loaded and are now cached, for
example textures and meshes. Note that a relative filename might be
interpreted differently on each call, depending on the current working
directory. In case you want to remove an archive that was added using
a relative path name, you have to change to the same working directory
again. This means, that the filename given on creation is not an
identifier for the archive, but just a usual filename that is used for
locating the archive to work with.
\param filename The archive pointed to by the name will be removed
\return True on success, false on failure */
virtual bool removeFileArchive(const path &filename) = 0;
//! Removes an archive from the file system.
/** This will close the archive and free any file handles, but will not
close resources which have already been loaded and are now cached, for
example textures and meshes.
\param archive The archive to remove.
\return True on success, false on failure */
virtual bool removeFileArchive(const IFileArchive *archive) = 0;
//! Changes the search order of attached archives.
/**
\param sourceIndex: The index of the archive to change
\param relative: The relative change in position, archives with a lower index are searched first */
virtual bool moveFileArchive(u32 sourceIndex, s32 relative) = 0;
//! Get the archive at a given index.
virtual IFileArchive *getFileArchive(u32 index) = 0;
//! Adds an external archive loader to the engine.
/** Use this function to add support for new archive types to the
engine, for example proprietary or encrypted file storage. */
virtual void addArchiveLoader(IArchiveLoader *loader) = 0;
//! Gets the number of archive loaders currently added
virtual u32 getArchiveLoaderCount() const = 0;
//! Retrieve the given archive loader
/** \param index The index of the loader to retrieve. This parameter is an 0-based
array index.
\return A pointer to the specified loader, 0 if the index is incorrect. */
virtual IArchiveLoader *getArchiveLoader(u32 index) const = 0;
//! Get the current working directory.
/** \return Current working directory as a string. */
virtual const path &getWorkingDirectory() = 0;
//! Changes the current working directory.
/** \param newDirectory: A string specifying the new working directory.
The string is operating system dependent. Under Windows it has
the form "<drive>:\<directory>\<sudirectory>\<..>". An example would be: "C:\Windows\"
\return True if successful, otherwise false. */
virtual bool changeWorkingDirectoryTo(const path &newDirectory) = 0;
//! Converts a relative path to an absolute (unique) path, resolving symbolic links if required
/** \param filename Possibly relative file or directory name to query.
\result Absolute filename which points to the same file. */
virtual path getAbsolutePath(const path &filename) const = 0;
//! Get the directory a file is located in.
/** \param filename: The file to get the directory from.
\return String containing the directory of the file. */
virtual path getFileDir(const path &filename) const = 0;
//! Get the base part of a filename, i.e. the name without the directory part.
/** If no directory is prefixed, the full name is returned.
\param filename: The file to get the basename from
\param keepExtension True if filename with extension is returned otherwise everything
after the final '.' is removed as well. */
virtual path getFileBasename(const path &filename, bool keepExtension = true) const = 0;
//! flatten a path and file name for example: "/you/me/../." becomes "/you"
virtual path &flattenFilename(path &directory, const path &root = "/") const = 0;
//! Get the relative filename, relative to the given directory
virtual path getRelativeFilename(const path &filename, const path &directory) const = 0;
//! Creates a list of files and directories in the current working directory and returns it.
/** \return a Pointer to the created IFileList is returned. After the list has been used
it has to be deleted using its IFileList::drop() method.
See IReferenceCounted::drop() for more information. */
virtual IFileList *createFileList() = 0;
//! Creates an empty filelist
/** \return a Pointer to the created IFileList is returned. After the list has been used
it has to be deleted using its IFileList::drop() method.
See IReferenceCounted::drop() for more information. */
virtual IFileList *createEmptyFileList(const io::path &path, bool ignoreCase, bool ignorePaths) = 0;
//! Set the active type of file system.
virtual EFileSystemType setFileListSystem(EFileSystemType listType) = 0;
//! Determines if a file exists and could be opened.
/** \param filename is the string identifying the file which should be tested for existence.
\return True if file exists, and false if it does not exist or an error occurred. */
virtual bool existFile(const path &filename) const = 0;
};
} // end namespace io
} // end namespace irr

369
irr/include/IGPUProgrammingServices.h Normal file
View File

@ -0,0 +1,369 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "EShaderTypes.h"
#include "EMaterialTypes.h"
#include "EPrimitiveTypes.h"
#include "path.h"
namespace irr
{
namespace io
{
class IReadFile;
} // end namespace io
namespace video
{
class IVideoDriver;
class IShaderConstantSetCallBack;
//! Interface making it possible to create and use programs running on the GPU.
class IGPUProgrammingServices
{
public:
//! Destructor
virtual ~IGPUProgrammingServices() {}
//! Adds a new high-level shading material renderer to the VideoDriver.
/** Currently only HLSL/D3D9 and GLSL/OpenGL are supported.
\param vertexShaderProgram String containing the source of the vertex
shader program. This can be 0 if no vertex program shall be used.
\param vertexShaderEntryPointName Name of the entry function of the
vertexShaderProgram (p.e. "main")
\param vsCompileTarget Vertex shader version the high level shader
shall be compiled to.
\param pixelShaderProgram String containing the source of the pixel
shader program. This can be 0 if no pixel shader shall be used.
\param pixelShaderEntryPointName Entry name of the function of the
pixelShaderProgram (p.e. "main")
\param psCompileTarget Pixel shader version the high level shader
shall be compiled to.
\param geometryShaderProgram String containing the source of the
geometry shader program. This can be 0 if no geometry shader shall be
used.
\param geometryShaderEntryPointName Entry name of the function of the
geometryShaderProgram (p.e. "main")
\param gsCompileTarget Geometry shader version the high level shader
shall be compiled to.
\param inType Type of vertices passed to geometry shader
\param outType Type of vertices created by geometry shader
\param verticesOut Maximal number of vertices created by geometry
shader. If 0, maximal number supported is assumed.
\param callback Pointer to an implementation of
IShaderConstantSetCallBack in which you can set the needed vertex,
pixel, and geometry shader program constants. Set this to 0 if you
don't need this.
\param baseMaterial Base material which renderstates will be used to
shade the material.
\param userData a user data int. This int can be set to any value and
will be set as parameter in the callback method when calling
OnSetConstants(). In this way it is easily possible to use the same
callback method for multiple materials and distinguish between them
during the call.
\return Number of the material type which can be set in
SMaterial::MaterialType to use the renderer. -1 is returned if an error
occurred, e.g. if a shader program could not be compiled or a compile
target is not reachable. The error strings are then printed to the
error log and can be caught with a custom event receiver. */
virtual s32 addHighLevelShaderMaterial(
const c8 *vertexShaderProgram,
const c8 *vertexShaderEntryPointName,
E_VERTEX_SHADER_TYPE vsCompileTarget,
const c8 *pixelShaderProgram,
const c8 *pixelShaderEntryPointName,
E_PIXEL_SHADER_TYPE psCompileTarget,
const c8 *geometryShaderProgram,
const c8 *geometryShaderEntryPointName = "main",
E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
u32 verticesOut = 0,
IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0) = 0;
//! convenience function for use without geometry shaders
s32 addHighLevelShaderMaterial(
const c8 *vertexShaderProgram,
const c8 *vertexShaderEntryPointName = "main",
E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
const c8 *pixelShaderProgram = 0,
const c8 *pixelShaderEntryPointName = "main",
E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0)
{
return addHighLevelShaderMaterial(
vertexShaderProgram, vertexShaderEntryPointName,
vsCompileTarget, pixelShaderProgram,
pixelShaderEntryPointName, psCompileTarget,
0, "main", EGST_GS_4_0,
scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
callback, baseMaterial, userData);
}
//! convenience function for use with many defaults, without geometry shader
/** All shader names are set to "main" and compile targets are shader
type 1.1.
*/
s32 addHighLevelShaderMaterial(
const c8 *vertexShaderProgram,
const c8 *pixelShaderProgram = 0,
IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0)
{
return addHighLevelShaderMaterial(
vertexShaderProgram, "main",
EVST_VS_1_1, pixelShaderProgram,
"main", EPST_PS_1_1,
0, "main", EGST_GS_4_0,
scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
callback, baseMaterial, userData);
}
//! convenience function for use with many defaults, with geometry shader
/** All shader names are set to "main" and compile targets are shader
type 1.1 and geometry shader 4.0.
*/
s32 addHighLevelShaderMaterial(
const c8 *vertexShaderProgram,
const c8 *pixelShaderProgram = 0,
const c8 *geometryShaderProgram = 0,
scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
u32 verticesOut = 0,
IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0)
{
return addHighLevelShaderMaterial(
vertexShaderProgram, "main",
EVST_VS_1_1, pixelShaderProgram,
"main", EPST_PS_1_1,
geometryShaderProgram, "main", EGST_GS_4_0,
inType, outType, verticesOut,
callback, baseMaterial, userData);
}
//! Like addHighLevelShaderMaterial(), but loads from files.
/** \param vertexShaderProgramFileName Text file containing the source
of the vertex shader program. Set to empty string if no vertex shader
shall be created.
\param vertexShaderEntryPointName Name of the entry function of the
vertexShaderProgram (p.e. "main")
\param vsCompileTarget Vertex shader version the high level shader
shall be compiled to.
\param pixelShaderProgramFileName Text file containing the source of
the pixel shader program. Set to empty string if no pixel shader shall
be created.
\param pixelShaderEntryPointName Entry name of the function of the
pixelShaderProgram (p.e. "main")
\param psCompileTarget Pixel shader version the high level shader
shall be compiled to.
\param geometryShaderProgramFileName Name of the source of
the geometry shader program. Set to empty string if no geometry shader
shall be created.
\param geometryShaderEntryPointName Entry name of the function of the
geometryShaderProgram (p.e. "main")
\param gsCompileTarget Geometry shader version the high level shader
shall be compiled to.
\param inType Type of vertices passed to geometry shader
\param outType Type of vertices created by geometry shader
\param verticesOut Maximal number of vertices created by geometry
shader. If 0, maximal number supported is assumed.
\param callback Pointer to an implementation of
IShaderConstantSetCallBack in which you can set the needed vertex,
pixel, and geometry shader program constants. Set this to 0 if you
don't need this.
\param baseMaterial Base material which renderstates will be used to
shade the material.
\param userData a user data int. This int can be set to any value and
will be set as parameter in the callback method when calling
OnSetConstants(). In this way it is easily possible to use the same
callback method for multiple materials and distinguish between them
during the call.
\return Number of the material type which can be set in
SMaterial::MaterialType to use the renderer. -1 is returned if an error
occurred, e.g. if a shader program could not be compiled or a compile
target is not reachable. The error strings are then printed to the
error log and can be caught with a custom event receiver. */
virtual s32 addHighLevelShaderMaterialFromFiles(
const io::path &vertexShaderProgramFileName,
const c8 *vertexShaderEntryPointName,
E_VERTEX_SHADER_TYPE vsCompileTarget,
const io::path &pixelShaderProgramFileName,
const c8 *pixelShaderEntryPointName,
E_PIXEL_SHADER_TYPE psCompileTarget,
const io::path &geometryShaderProgramFileName,
const c8 *geometryShaderEntryPointName = "main",
E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
u32 verticesOut = 0,
IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0) = 0;
//! convenience function for use without geometry shaders
s32 addHighLevelShaderMaterialFromFiles(
const io::path &vertexShaderProgramFileName,
const c8 *vertexShaderEntryPointName = "main",
E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
const io::path &pixelShaderProgramFileName = "",
const c8 *pixelShaderEntryPointName = "main",
E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0)
{
return addHighLevelShaderMaterialFromFiles(
vertexShaderProgramFileName, vertexShaderEntryPointName,
vsCompileTarget, pixelShaderProgramFileName,
pixelShaderEntryPointName, psCompileTarget,
"", "main", EGST_GS_4_0,
scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
callback, baseMaterial, userData);
}
//! convenience function for use with many defaults, without geometry shader
/** All shader names are set to "main" and compile targets are shader
type 1.1.
*/
s32 addHighLevelShaderMaterialFromFiles(
const io::path &vertexShaderProgramFileName,
const io::path &pixelShaderProgramFileName = "",
IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0)
{
return addHighLevelShaderMaterialFromFiles(
vertexShaderProgramFileName, "main",
EVST_VS_1_1, pixelShaderProgramFileName,
"main", EPST_PS_1_1,
"", "main", EGST_GS_4_0,
scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
callback, baseMaterial, userData);
}
//! convenience function for use with many defaults, with geometry shader
/** All shader names are set to "main" and compile targets are shader
type 1.1 and geometry shader 4.0.
*/
s32 addHighLevelShaderMaterialFromFiles(
const io::path &vertexShaderProgramFileName,
const io::path &pixelShaderProgramFileName = "",
const io::path &geometryShaderProgramFileName = "",
scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
u32 verticesOut = 0,
IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0)
{
return addHighLevelShaderMaterialFromFiles(
vertexShaderProgramFileName, "main",
EVST_VS_1_1, pixelShaderProgramFileName,
"main", EPST_PS_1_1,
geometryShaderProgramFileName, "main", EGST_GS_4_0,
inType, outType, verticesOut,
callback, baseMaterial, userData);
}
//! Like addHighLevelShaderMaterial(), but loads from files.
/** \param vertexShaderProgram Text file handle containing the source
of the vertex shader program. Set to 0 if no vertex shader shall be
created.
\param vertexShaderEntryPointName Name of the entry function of the
vertexShaderProgram
\param vsCompileTarget Vertex shader version the high level shader
shall be compiled to.
\param pixelShaderProgram Text file handle containing the source of
the pixel shader program. Set to 0 if no pixel shader shall be created.
\param pixelShaderEntryPointName Entry name of the function of the
pixelShaderProgram (p.e. "main")
\param psCompileTarget Pixel shader version the high level shader
shall be compiled to.
\param geometryShaderProgram Text file handle containing the source of
the geometry shader program. Set to 0 if no geometry shader shall be
created.
\param geometryShaderEntryPointName Entry name of the function of the
geometryShaderProgram (p.e. "main")
\param gsCompileTarget Geometry shader version the high level shader
shall be compiled to.
\param inType Type of vertices passed to geometry shader
\param outType Type of vertices created by geometry shader
\param verticesOut Maximal number of vertices created by geometry
shader. If 0, maximal number supported is assumed.
\param callback Pointer to an implementation of
IShaderConstantSetCallBack in which you can set the needed vertex and
pixel shader program constants. Set this to 0 if you don't need this.
\param baseMaterial Base material which renderstates will be used to
shade the material.
\param userData a user data int. This int can be set to any value and
will be set as parameter in the callback method when calling
OnSetConstants(). In this way it is easily possible to use the same
callback method for multiple materials and distinguish between them
during the call.
\return Number of the material type which can be set in
SMaterial::MaterialType to use the renderer. -1 is returned if an
error occurred, e.g. if a shader program could not be compiled or a
compile target is not reachable. The error strings are then printed to
the error log and can be caught with a custom event receiver. */
virtual s32 addHighLevelShaderMaterialFromFiles(
io::IReadFile *vertexShaderProgram,
const c8 *vertexShaderEntryPointName,
E_VERTEX_SHADER_TYPE vsCompileTarget,
io::IReadFile *pixelShaderProgram,
const c8 *pixelShaderEntryPointName,
E_PIXEL_SHADER_TYPE psCompileTarget,
io::IReadFile *geometryShaderProgram,
const c8 *geometryShaderEntryPointName = "main",
E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
u32 verticesOut = 0,
IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0) = 0;
//! convenience function for use without geometry shaders
s32 addHighLevelShaderMaterialFromFiles(
io::IReadFile *vertexShaderProgram,
const c8 *vertexShaderEntryPointName = "main",
E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
io::IReadFile *pixelShaderProgram = 0,
const c8 *pixelShaderEntryPointName = "main",
E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0)
{
return addHighLevelShaderMaterialFromFiles(
vertexShaderProgram, vertexShaderEntryPointName,
vsCompileTarget, pixelShaderProgram,
pixelShaderEntryPointName, psCompileTarget,
0, "main", EGST_GS_4_0,
scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
callback, baseMaterial, userData);
}
//! Delete a shader material and associated data.
/**
After you have deleted a material it is invalid to still use and doing
so might result in a crash. The ID may be reused in the future when new
materials are added.
\param material Number of the material type. Must not be a built-in
material. */
virtual void deleteShaderMaterial(s32 material) = 0;
};
} // end namespace video
} // end namespace irr

259
irr/include/IGUIButton.h Normal file
View File

@ -0,0 +1,259 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIElement.h"
namespace irr
{
namespace video
{
class ITexture;
} // end namespace video
namespace gui
{
class IGUIFont;
class IGUISpriteBank;
//! Current state of buttons used for drawing sprites.
//! Note that up to 3 states can be active at the same time:
//! EGBS_BUTTON_UP or EGBS_BUTTON_DOWN
//! EGBS_BUTTON_MOUSE_OVER or EGBS_BUTTON_MOUSE_OFF
//! EGBS_BUTTON_FOCUSED or EGBS_BUTTON_NOT_FOCUSED
enum EGUI_BUTTON_STATE
{
//! The button is not pressed.
EGBS_BUTTON_UP = 0,
//! The button is currently pressed down.
EGBS_BUTTON_DOWN,
//! The mouse cursor is over the button
EGBS_BUTTON_MOUSE_OVER,
//! The mouse cursor is not over the button
EGBS_BUTTON_MOUSE_OFF,
//! The button has the focus
EGBS_BUTTON_FOCUSED,
//! The button doesn't have the focus
EGBS_BUTTON_NOT_FOCUSED,
//! The button is disabled All other states are ignored in that case.
EGBS_BUTTON_DISABLED,
//! not used, counts the number of enumerated items
EGBS_COUNT
};
//! Names for gui button state icons
const c8 *const GUIButtonStateNames[EGBS_COUNT + 1] = {
"buttonUp",
"buttonDown",
"buttonMouseOver",
"buttonMouseOff",
"buttonFocused",
"buttonNotFocused",
"buttonDisabled",
0, // count
};
//! State of buttons used for drawing texture images.
//! Note that only a single state is active at a time
//! Also when no image is defined for a state it will use images from another state
//! and if that state is not set from the replacement for that,etc.
//! So in many cases setting EGBIS_IMAGE_UP and EGBIS_IMAGE_DOWN is sufficient.
enum EGUI_BUTTON_IMAGE_STATE
{
//! When no other states have images they will all use this one.
EGBIS_IMAGE_UP,
//! When not set EGBIS_IMAGE_UP is used.
EGBIS_IMAGE_UP_MOUSEOVER,
//! When not set EGBIS_IMAGE_UP_MOUSEOVER is used.
EGBIS_IMAGE_UP_FOCUSED,
//! When not set EGBIS_IMAGE_UP_FOCUSED is used.
EGBIS_IMAGE_UP_FOCUSED_MOUSEOVER,
//! When not set EGBIS_IMAGE_UP is used.
EGBIS_IMAGE_DOWN,
//! When not set EGBIS_IMAGE_DOWN is used.
EGBIS_IMAGE_DOWN_MOUSEOVER,
//! When not set EGBIS_IMAGE_DOWN_MOUSEOVER is used.
EGBIS_IMAGE_DOWN_FOCUSED,
//! When not set EGBIS_IMAGE_DOWN_FOCUSED is used.
EGBIS_IMAGE_DOWN_FOCUSED_MOUSEOVER,
//! When not set EGBIS_IMAGE_UP or EGBIS_IMAGE_DOWN are used (depending on button state).
EGBIS_IMAGE_DISABLED,
//! not used, counts the number of enumerated items
EGBIS_COUNT
};
//! Names for gui button image states
const c8 *const GUIButtonImageStateNames[EGBIS_COUNT + 1] = {
"Image", // not "ImageUp" as it otherwise breaks serialization of old files
"ImageUpOver",
"ImageUpFocused",
"ImageUpFocusedOver",
"PressedImage", // not "ImageDown" as it otherwise breaks serialization of old files
"ImageDownOver",
"ImageDownFocused",
"ImageDownFocusedOver",
"ImageDisabled",
0, // count
};
//! GUI Button interface.
/** \par This element can create the following events of type EGUI_EVENT_TYPE:
\li EGET_BUTTON_CLICKED
*/
class IGUIButton : public IGUIElement
{
public:
//! constructor
IGUIButton(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_BUTTON, environment, parent, id, rectangle) {}
//! Sets another skin independent font.
/** If this is set to zero, the button uses the font of the skin.
\param font: New font to set. */
virtual void setOverrideFont(IGUIFont *font = 0) = 0;
//! Gets the override font (if any)
/** \return The override font (may be 0) */
virtual IGUIFont *getOverrideFont(void) const = 0;
//! Get the font which is used right now for drawing
/** Currently this is the override font when one is set and the
font of the active skin otherwise */
virtual IGUIFont *getActiveFont() const = 0;
//! Sets another color for the button text.
/** When set, this color is used instead of EGDC_BUTTON_TEXT/EGDC_GRAY_TEXT.
You don't need to call enableOverrideColor(true), that's done by this function.
If you want the the color of the skin back, call enableOverrideColor(false);
\param color: New color of the text. */
virtual void setOverrideColor(video::SColor color) = 0;
//! Gets the override color
/** \return: The override color */
virtual video::SColor getOverrideColor(void) const = 0;
//! Gets the currently used text color
/** Either a skin-color for the current state or the override color */
virtual video::SColor getActiveColor() const = 0;
//! Sets if the button text should use the override color or the color in the gui skin.
/** \param enable: If set to true, the override color, which can be set
with IGUIStaticText::setOverrideColor is used, otherwise the
EGDC_BUTTON_TEXT or EGDC_GRAY_TEXT color of the skin. */
virtual void enableOverrideColor(bool enable) = 0;
//! Checks if an override color is enabled
/** \return true if the override color is enabled, false otherwise */
virtual bool isOverrideColorEnabled(void) const = 0;
//! Sets an image which should be displayed on the button when it is in the given state.
/** Only one image-state can be active at a time. Images are drawn below sprites.
If a state is without image it will try to use images from other states as described
in ::EGUI_BUTTON_IMAGE_STATE.
Images are a little less flexible than sprites, but easier to use.
\param state: One of ::EGUI_BUTTON_IMAGE_STATE
\param image: Image to be displayed or NULL to remove the image
\param sourceRect: Source rectangle on the image texture. When width or height are 0 then the full texture-size is used (default). */
virtual void setImage(EGUI_BUTTON_IMAGE_STATE state, video::ITexture *image = 0, const core::rect<s32> &sourceRect = core::rect<s32>(0, 0, 0, 0)) = 0;
//! Sets an image which should be displayed on the button when it is in normal state.
/** This is identical to calling setImage(EGBIS_IMAGE_UP, image); and might be deprecated in future revisions.
\param image: Image to be displayed */
virtual void setImage(video::ITexture *image = 0) = 0;
//! Sets a background image for the button when it is in normal state.
/** This is identical to calling setImage(EGBIS_IMAGE_UP, image, sourceRect); and might be deprecated in future revisions.
\param image: Texture containing the image to be displayed
\param sourceRect: Position in the texture, where the image is located.
When width or height are 0 then the full texture-size is used */
virtual void setImage(video::ITexture *image, const core::rect<s32> &sourceRect) = 0;
//! Sets a background image for the button when it is in pressed state.
/** This is identical to calling setImage(EGBIS_IMAGE_DOWN, image); and might be deprecated in future revisions.
If no images is specified for the pressed state via
setPressedImage(), this image is also drawn in pressed state.
\param image: Image to be displayed */
virtual void setPressedImage(video::ITexture *image = 0) = 0;
//! Sets an image which should be displayed on the button when it is in pressed state.
/** This is identical to calling setImage(EGBIS_IMAGE_DOWN, image, sourceRect); and might be deprecated in future revisions.
\param image: Texture containing the image to be displayed
\param sourceRect: Position in the texture, where the image is located */
virtual void setPressedImage(video::ITexture *image, const core::rect<s32> &sourceRect) = 0;
//! Sets the sprite bank used by the button
/** NOTE: The spritebank itself is _not_ serialized so far. The sprites are serialized.
Which means after loading the gui you still have to set the spritebank manually. */
virtual void setSpriteBank(IGUISpriteBank *bank = 0) = 0;
//! Sets the animated sprite for a specific button state
/** Several sprites can be drawn at the same time.
Sprites can be animated.
Sprites are drawn above the images.
\param index: Number of the sprite within the sprite bank, use -1 for no sprite
\param state: State of the button to set the sprite for
\param index: The sprite number from the current sprite bank
\param color: The color of the sprite
\param loop: True if the animation should loop, false if not
\param scale: True if the sprite should scale to button size, false if not */
virtual void setSprite(EGUI_BUTTON_STATE state, s32 index,
video::SColor color = video::SColor(255, 255, 255, 255), bool loop = false, bool scale = false) = 0;
//! Get the sprite-index for the given state or -1 when no sprite is set
virtual s32 getSpriteIndex(EGUI_BUTTON_STATE state) const = 0;
//! Get the sprite color for the given state. Color is only used when a sprite is set.
virtual video::SColor getSpriteColor(EGUI_BUTTON_STATE state) const = 0;
//! Returns if the sprite in the given state does loop
virtual bool getSpriteLoop(EGUI_BUTTON_STATE state) const = 0;
//! Returns if the sprite in the given state is scaled
virtual bool getSpriteScale(EGUI_BUTTON_STATE state) const = 0;
//! Sets if the button should behave like a push button.
/** Which means it can be in two states: Normal or Pressed. With a click on the button,
the user can change the state of the button. */
virtual void setIsPushButton(bool isPushButton = true) = 0;
//! Sets the pressed state of the button if this is a pushbutton
virtual void setPressed(bool pressed = true) = 0;
//! Returns if the button is currently pressed
virtual bool isPressed() const = 0;
//! Sets if the alpha channel should be used for drawing background images on the button (default is false)
virtual void setUseAlphaChannel(bool useAlphaChannel = true) = 0;
//! Returns if the alpha channel should be used for drawing background images on the button
virtual bool isAlphaChannelUsed() const = 0;
//! Returns whether the button is a push button
virtual bool isPushButton() const = 0;
//! Sets if the button should use the skin to draw its border and button face (default is true)
virtual void setDrawBorder(bool border = true) = 0;
//! Returns if the border and button face are being drawn using the skin
virtual bool isDrawingBorder() const = 0;
//! Sets if the button should scale the button images to fit
virtual void setScaleImage(bool scaleImage = true) = 0;
//! Checks whether the button scales the used images
virtual bool isScalingImage() const = 0;
//! Get if the shift key was pressed in last EGET_BUTTON_CLICKED event
/** Generated together with event, so info is available in the event-receiver. */
virtual bool getClickShiftState() const = 0;
//! Get if the control key was pressed in last EGET_BUTTON_CLICKED event
/** Generated together with event, so info is available in the event-receiver. */
virtual bool getClickControlState() const = 0;
};
} // end namespace gui
} // end namespace irr

47
irr/include/IGUICheckBox.h Normal file
View File

@ -0,0 +1,47 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIElement.h"
namespace irr
{
namespace gui
{
//! GUI Check box interface.
/** \par This element can create the following events of type EGUI_EVENT_TYPE:
\li EGET_CHECKBOX_CHANGED
*/
class IGUICheckBox : public IGUIElement
{
public:
//! constructor
IGUICheckBox(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_CHECK_BOX, environment, parent, id, rectangle) {}
//! Set if box is checked.
virtual void setChecked(bool checked) = 0;
//! Returns true if box is checked.
virtual bool isChecked() const = 0;
//! Sets whether to draw the background
virtual void setDrawBackground(bool draw) = 0;
//! Checks if background drawing is enabled
/** \return true if background drawing is enabled, false otherwise */
virtual bool isDrawBackgroundEnabled() const = 0;
//! Sets whether to draw the border
virtual void setDrawBorder(bool draw) = 0;
//! Checks if border drawing is enabled
/** \return true if border drawing is enabled, false otherwise */
virtual bool isDrawBorderEnabled() const = 0;
};
} // end namespace gui
} // end namespace irr

72
irr/include/IGUIComboBox.h Normal file
View File

@ -0,0 +1,72 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIElement.h"
namespace irr
{
namespace gui
{
//! Combobox widget
/** \par This element can create the following events of type EGUI_EVENT_TYPE:
\li EGET_COMBO_BOX_CHANGED
*/
class IGUIComboBox : public IGUIElement
{
public:
//! constructor
IGUIComboBox(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_COMBO_BOX, environment, parent, id, rectangle) {}
//! Returns amount of items in box
virtual u32 getItemCount() const = 0;
//! Returns string of an item. the idx may be a value from 0 to itemCount-1
virtual const wchar_t *getItem(u32 idx) const = 0;
//! Returns item data of an item. the idx may be a value from 0 to itemCount-1
virtual u32 getItemData(u32 idx) const = 0;
//! Returns index based on item data
virtual s32 getIndexForItemData(u32 data) const = 0;
//! Adds an item and returns the index of it
virtual u32 addItem(const wchar_t *text, u32 data = 0) = 0;
//! Removes an item from the combo box.
/** Warning. This will change the index of all following items */
virtual void removeItem(u32 idx) = 0;
//! Deletes all items in the combo box
virtual void clear() = 0;
//! Returns id of selected item. returns -1 if no item is selected.
virtual s32 getSelected() const = 0;
//! Sets the selected item. Set this to -1 if no item should be selected
virtual void setSelected(s32 idx) = 0;
//! Sets the selected item and emits a change event.
/** Set this to -1 if no item should be selected */
virtual void setAndSendSelected(s32 idx) = 0;
//! Sets text justification of the text area
/** \param horizontal: EGUIA_UPPERLEFT for left justified (default),
EGUIA_LOWERRIGHT for right justified, or EGUIA_CENTER for centered text.
\param vertical: EGUIA_UPPERLEFT to align with top edge,
EGUIA_LOWERRIGHT for bottom edge, or EGUIA_CENTER for centered text (default). */
virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical) = 0;
//! Set the maximal number of rows for the selection listbox
virtual void setMaxSelectionRows(u32 max) = 0;
//! Get the maximal number of rows for the selection listbox
virtual u32 getMaxSelectionRows() const = 0;
};
} // end namespace gui
} // end namespace irr

151
irr/include/IGUIEditBox.h Normal file
View File

@ -0,0 +1,151 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIElement.h"
#include "SColor.h"
namespace irr
{
namespace gui
{
class IGUIFont;
//! Single line edit box for editing simple text.
/** \par This element can create the following events of type EGUI_EVENT_TYPE:
\li EGET_EDITBOX_ENTER
\li EGET_EDITBOX_CHANGED
\li EGET_EDITBOX_MARKING_CHANGED
*/
class IGUIEditBox : public IGUIElement
{
public:
//! constructor
IGUIEditBox(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_EDIT_BOX, environment, parent, id, rectangle) {}
//! Sets another skin independent font.
/** If this is set to zero, the button uses the font of the skin.
\param font: New font to set. */
virtual void setOverrideFont(IGUIFont *font = 0) = 0;
//! Gets the override font (if any)
/** \return The override font (may be 0) */
virtual IGUIFont *getOverrideFont() const = 0;
//! Get the font which is used right now for drawing
/** Currently this is the override font when one is set and the
font of the active skin otherwise */
virtual IGUIFont *getActiveFont() const = 0;
//! Sets another color for the text.
/** If set, the edit box does not use the EGDC_BUTTON_TEXT color defined
in the skin, but the set color instead. You don't need to call
IGUIEditBox::enableOverrrideColor(true) after this, this is done
by this function.
If you set a color, and you want the text displayed with the color
of the skin again, call IGUIEditBox::enableOverrideColor(false);
\param color: New color of the text. */
virtual void setOverrideColor(video::SColor color) = 0;
//! Gets the override color
virtual video::SColor getOverrideColor() const = 0;
//! Sets if the text should use the override color or the color in the gui skin.
/** \param enable: If set to true, the override color, which can be set
with IGUIEditBox::setOverrideColor is used, otherwise the
EGDC_BUTTON_TEXT color of the skin. */
virtual void enableOverrideColor(bool enable) = 0;
//! Checks if an override color is enabled
/** \return true if the override color is enabled, false otherwise */
virtual bool isOverrideColorEnabled(void) const = 0;
//! Sets whether to draw the background
virtual void setDrawBackground(bool draw) = 0;
//! Checks if background drawing is enabled
/** \return true if background drawing is enabled, false otherwise */
virtual bool isDrawBackgroundEnabled() const = 0;
//! Turns the border on or off
/** \param border: true if you want the border to be drawn, false if not */
virtual void setDrawBorder(bool border) = 0;
//! Checks if border drawing is enabled
/** \return true if border drawing is enabled, false otherwise */
virtual bool isDrawBorderEnabled() const = 0;
//! Sets text justification mode
/** \param horizontal: EGUIA_UPPERLEFT for left justified (default),
EGUIA_LOWERRIGHT for right justified, or EGUIA_CENTER for centered text.
\param vertical: EGUIA_UPPERLEFT to align with top edge,
EGUIA_LOWERRIGHT for bottom edge, or EGUIA_CENTER for centered text (default). */
virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical) = 0;
//! Enables or disables word wrap.
/** \param enable: If set to true, words going over one line are
broken to the next line. */
virtual void setWordWrap(bool enable) = 0;
//! Checks if word wrap is enabled
/** \return true if word wrap is enabled, false otherwise */
virtual bool isWordWrapEnabled() const = 0;
//! Enables or disables newlines.
/** \param enable: If set to true, the EGET_EDITBOX_ENTER event will not be fired,
instead a newline character will be inserted. */
virtual void setMultiLine(bool enable) = 0;
//! Checks if multi line editing is enabled
/** \return true if multi-line is enabled, false otherwise */
virtual bool isMultiLineEnabled() const = 0;
//! Enables or disables automatic scrolling with cursor position
/** \param enable: If set to true, the text will move around with the cursor position */
virtual void setAutoScroll(bool enable) = 0;
//! Checks to see if automatic scrolling is enabled
/** \return true if automatic scrolling is enabled, false if not */
virtual bool isAutoScrollEnabled() const = 0;
//! Sets whether the edit box is a password box. Setting this to true will
/** disable MultiLine, WordWrap and the ability to copy with ctrl+c or ctrl+x
\param passwordBox: true to enable password, false to disable
\param passwordChar: the character that is displayed instead of letters */
virtual void setPasswordBox(bool passwordBox, wchar_t passwordChar = L'*') = 0;
//! Returns true if the edit box is currently a password box.
virtual bool isPasswordBox() const = 0;
//! Gets the size area of the text in the edit box
/** \return The size in pixels of the text */
virtual core::dimension2du getTextDimension() = 0;
//! Sets the maximum amount of characters which may be entered in the box.
/** \param max: Maximum amount of characters. If 0, the character amount is
infinity. */
virtual void setMax(u32 max) = 0;
//! Returns maximum amount of characters, previously set by setMax();
virtual u32 getMax() const = 0;
//! Set the character used for the cursor.
/** By default it's "_" */
virtual void setCursorChar(const wchar_t cursorChar) = 0;
//! Get the character used for the cursor.
virtual wchar_t getCursorChar() const = 0;
//! Set the blinktime for the cursor. 2x blinktime is one full cycle.
//** \param timeMs Blinktime in milliseconds. When set to 0 the cursor is constantly on without blinking */
virtual void setCursorBlinkTime(irr::u32 timeMs) = 0;
//! Get the cursor blinktime
virtual irr::u32 getCursorBlinkTime() const = 0;
};
} // end namespace gui
} // end namespace irr

941
irr/include/IGUIElement.h Normal file
View File

@ -0,0 +1,941 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "rect.h"
#include "irrString.h"
#include "IEventReceiver.h"
#include "EGUIElementTypes.h"
#include "EGUIAlignment.h"
#include "IAttributes.h"
#include "IGUIEnvironment.h"
#include <cassert>
#include <algorithm>
#include <list>
#include <vector>
namespace irr
{
namespace gui
{
//! Base class of all GUI elements.
class IGUIElement : virtual public IReferenceCounted, public IEventReceiver
{
public:
//! Constructor
IGUIElement(EGUI_ELEMENT_TYPE type, IGUIEnvironment *environment, IGUIElement *parent,
s32 id, const core::rect<s32> &rectangle) :
Parent(0),
RelativeRect(rectangle), AbsoluteRect(rectangle),
AbsoluteClippingRect(rectangle), DesiredRect(rectangle),
MaxSize(0, 0), MinSize(1, 1), IsVisible(true), IsEnabled(true),
IsSubElement(false), NoClip(false), ID(id), IsTabStop(false), TabOrder(-1), IsTabGroup(false),
AlignLeft(EGUIA_UPPERLEFT), AlignRight(EGUIA_UPPERLEFT), AlignTop(EGUIA_UPPERLEFT), AlignBottom(EGUIA_UPPERLEFT),
Environment(environment), Type(type)
{
#ifdef _DEBUG
setDebugName("IGUIElement");
#endif
// if we were given a parent to attach to
if (parent) {
parent->addChildToEnd(this);
recalculateAbsolutePosition(true);
}
}
//! Destructor
virtual ~IGUIElement()
{
for (auto child : Children) {
child->Parent = nullptr;
child->drop();
}
}
//! Returns parent of this element.
IGUIElement *getParent() const
{
return Parent;
}
//! Returns the relative rectangle of this element.
core::rect<s32> getRelativePosition() const
{
return RelativeRect;
}
//! Sets the relative rectangle of this element.
/** \param r The absolute position to set */
void setRelativePosition(const core::rect<s32> &r)
{
if (Parent) {
const core::rect<s32> &r2 = Parent->getAbsolutePosition();
core::dimension2df d((f32)(r2.getSize().Width), (f32)(r2.getSize().Height));
if (AlignLeft == EGUIA_SCALE)
ScaleRect.UpperLeftCorner.X = (f32)r.UpperLeftCorner.X / d.Width;
if (AlignRight == EGUIA_SCALE)
ScaleRect.LowerRightCorner.X = (f32)r.LowerRightCorner.X / d.Width;
if (AlignTop == EGUIA_SCALE)
ScaleRect.UpperLeftCorner.Y = (f32)r.UpperLeftCorner.Y / d.Height;
if (AlignBottom == EGUIA_SCALE)
ScaleRect.LowerRightCorner.Y = (f32)r.LowerRightCorner.Y / d.Height;
}
DesiredRect = r;
updateAbsolutePosition();
}
//! Sets the relative rectangle of this element, maintaining its current width and height
/** \param position The new relative position to set. Width and height will not be changed. */
void setRelativePosition(const core::position2di &position)
{
const core::dimension2di mySize = RelativeRect.getSize();
const core::rect<s32> rectangle(position.X, position.Y,
position.X + mySize.Width, position.Y + mySize.Height);
setRelativePosition(rectangle);
}
//! Sets the relative rectangle of this element as a proportion of its parent's area.
/** \note This method used to be 'void setRelativePosition(const core::rect<f32>& r)'
\param r The rectangle to set, interpreted as a proportion of the parent's area.
Meaningful values are in the range [0...1], unless you intend this element to spill
outside its parent. */
void setRelativePositionProportional(const core::rect<f32> &r)
{
if (!Parent)
return;
const core::dimension2di &d = Parent->getAbsolutePosition().getSize();
DesiredRect = core::rect<s32>(
core::floor32((f32)d.Width * r.UpperLeftCorner.X),
core::floor32((f32)d.Height * r.UpperLeftCorner.Y),
core::floor32((f32)d.Width * r.LowerRightCorner.X),
core::floor32((f32)d.Height * r.LowerRightCorner.Y));
ScaleRect = r;
updateAbsolutePosition();
}
//! Gets the absolute rectangle of this element
core::rect<s32> getAbsolutePosition() const
{
return AbsoluteRect;
}
//! Returns the visible area of the element.
core::rect<s32> getAbsoluteClippingRect() const
{
return AbsoluteClippingRect;
}
//! Sets whether the element will ignore its parent's clipping rectangle
/** \param noClip If true, the element will not be clipped by its parent's clipping rectangle. */
void setNotClipped(bool noClip)
{
NoClip = noClip;
updateAbsolutePosition();
}
//! Gets whether the element will ignore its parent's clipping rectangle
/** \return true if the element is not clipped by its parent's clipping rectangle. */
bool isNotClipped() const
{
return NoClip;
}
//! Sets the maximum size allowed for this element
/** If set to 0,0, there is no maximum size */
void setMaxSize(core::dimension2du size)
{
MaxSize = size;
updateAbsolutePosition();
}
//! Sets the minimum size allowed for this element
void setMinSize(core::dimension2du size)
{
MinSize = size;
if (MinSize.Width < 1)
MinSize.Width = 1;
if (MinSize.Height < 1)
MinSize.Height = 1;
updateAbsolutePosition();
}
//! The alignment defines how the borders of this element will be positioned when the parent element is resized.
void setAlignment(EGUI_ALIGNMENT left, EGUI_ALIGNMENT right, EGUI_ALIGNMENT top, EGUI_ALIGNMENT bottom)
{
AlignLeft = left;
AlignRight = right;
AlignTop = top;
AlignBottom = bottom;
if (Parent) {
core::rect<s32> r(Parent->getAbsolutePosition());
core::dimension2df d((f32)r.getSize().Width, (f32)r.getSize().Height);
if (AlignLeft == EGUIA_SCALE)
ScaleRect.UpperLeftCorner.X = (f32)DesiredRect.UpperLeftCorner.X / d.Width;
if (AlignRight == EGUIA_SCALE)
ScaleRect.LowerRightCorner.X = (f32)DesiredRect.LowerRightCorner.X / d.Width;
if (AlignTop == EGUIA_SCALE)
ScaleRect.UpperLeftCorner.Y = (f32)DesiredRect.UpperLeftCorner.Y / d.Height;
if (AlignBottom == EGUIA_SCALE)
ScaleRect.LowerRightCorner.Y = (f32)DesiredRect.LowerRightCorner.Y / d.Height;
}
}
//! How left element border is aligned when parent is resized
EGUI_ALIGNMENT getAlignLeft() const
{
return AlignLeft;
}
//! How right element border is aligned when parent is resized
EGUI_ALIGNMENT getAlignRight() const
{
return AlignRight;
}
//! How top element border is aligned when parent is resized
EGUI_ALIGNMENT getAlignTop() const
{
return AlignTop;
}
//! How bottom element border is aligned when parent is resized
EGUI_ALIGNMENT getAlignBottom() const
{
return AlignBottom;
}
//! Updates the absolute position.
virtual void updateAbsolutePosition()
{
recalculateAbsolutePosition(false);
// update all children
for (auto child : Children) {
child->updateAbsolutePosition();
}
}
//! Returns the topmost GUI element at the specific position.
/**
This will check this GUI element and all of its descendants, so it
may return this GUI element. To check all GUI elements, call this
function on device->getGUIEnvironment()->getRootGUIElement(). Note
that the root element is the size of the screen, so doing so (with
an on-screen point) will always return the root element if no other
element is above it at that point.
\param point: The point at which to find a GUI element.
\return The topmost GUI element at that point, or 0 if there are
no candidate elements at this point.
*/
virtual IGUIElement *getElementFromPoint(const core::position2d<s32> &point)
{
IGUIElement *target = 0;
if (isVisible()) {
// we have to search from back to front, because later children
// might be drawn over the top of earlier ones.
auto it = Children.rbegin();
auto ie = Children.rend();
while (it != ie) {
target = (*it)->getElementFromPoint(point);
if (target)
return target;
++it;
}
}
if (isVisible() && isPointInside(point))
target = this;
return target;
}
//! Returns true if a point is within this element.
/** Elements with a shape other than a rectangle should override this method */
virtual bool isPointInside(const core::position2d<s32> &point) const
{
return AbsoluteClippingRect.isPointInside(point);
}
//! Adds a GUI element as new child of this element.
virtual void addChild(IGUIElement *child)
{
if (child && child != this) {
addChildToEnd(child);
child->updateAbsolutePosition();
}
}
//! Removes a child.
virtual void removeChild(IGUIElement *child)
{
assert(child->Parent == this);
Children.erase(child->ParentPos);
child->Parent = nullptr;
child->drop();
}
//! Removes all children.
virtual void removeAllChildren()
{
while (!Children.empty()) {
auto child = Children.back();
child->remove();
}
}
//! Removes this element from its parent.
virtual void remove()
{
if (Parent)
Parent->removeChild(this);
}
//! Draws the element and its children.
virtual void draw()
{
if (isVisible()) {
for (auto child : Children)
child->draw();
}
}
//! animate the element and its children.
virtual void OnPostRender(u32 timeMs)
{
if (isVisible()) {
for (auto child : Children)
child->OnPostRender(timeMs);
}
}
//! Moves this element.
virtual void move(core::position2d<s32> absoluteMovement)
{
setRelativePosition(DesiredRect + absoluteMovement);
}
//! Returns true if element is visible.
virtual bool isVisible() const
{
return IsVisible;
}
//! Check whether the element is truly visible, taking into accounts its parents' visibility
/** \return true if the element and all its parents are visible,
false if this or any parent element is invisible. */
virtual bool isTrulyVisible() const
{
if (!IsVisible)
return false;
if (!Parent)
return true;
return Parent->isTrulyVisible();
}
//! Sets the visible state of this element.
virtual void setVisible(bool visible)
{
IsVisible = visible;
}
//! Returns true if this element was created as part of its parent control
virtual bool isSubElement() const
{
return IsSubElement;
}
//! Sets whether this control was created as part of its parent.
/** For example, it is true when a scrollbar is part of a listbox.
SubElements are not saved to disk when calling guiEnvironment->saveGUI() */
virtual void setSubElement(bool subElement)
{
IsSubElement = subElement;
}
//! If set to true, the focus will visit this element when using the tab key to cycle through elements.
/** If this element is a tab group (see isTabGroup/setTabGroup) then
ctrl+tab will be used instead. */
void setTabStop(bool enable)
{
IsTabStop = enable;
}
//! Returns true if this element can be focused by navigating with the tab key
bool isTabStop() const
{
return IsTabStop;
}
//! Sets the priority of focus when using the tab key to navigate between a group of elements.
/** See setTabGroup, isTabGroup and getTabGroup for information on tab groups.
Elements with a lower number are focused first */
void setTabOrder(s32 index)
{
// negative = autonumber
if (index < 0) {
TabOrder = 0;
IGUIElement *el = getTabGroup();
while (IsTabGroup && el && el->Parent)
el = el->Parent;
IGUIElement *first = 0, *closest = 0;
if (el) {
// find the highest element number
el->getNextElement(-1, true, IsTabGroup, first, closest, true, true);
if (first) {
TabOrder = first->getTabOrder() + 1;
}
}
} else
TabOrder = index;
}
//! Returns the number in the tab order sequence
s32 getTabOrder() const
{
return TabOrder;
}
//! Sets whether this element is a container for a group of elements which can be navigated using the tab key.
/** For example, windows are tab groups.
Groups can be navigated using ctrl+tab, providing isTabStop is true. */
void setTabGroup(bool isGroup)
{
IsTabGroup = isGroup;
}
//! Returns true if this element is a tab group.
bool isTabGroup() const
{
return IsTabGroup;
}
//! Returns the container element which holds all elements in this element's tab group.
IGUIElement *getTabGroup()
{
IGUIElement *ret = this;
while (ret && !ret->isTabGroup())
ret = ret->getParent();
return ret;
}
//! Returns true if element is enabled
/** Currently elements do _not_ care about parent-states.
So if you want to affect children you have to enable/disable them all.
The only exception to this are sub-elements which also check their parent.
*/
virtual bool isEnabled() const
{
if (isSubElement() && IsEnabled && getParent())
return getParent()->isEnabled();
return IsEnabled;
}
//! Sets the enabled state of this element.
virtual void setEnabled(bool enabled)
{
IsEnabled = enabled;
}
//! Sets the new caption of this element.
virtual void setText(const wchar_t *text)
{
Text = text;
}
//! Returns caption of this element.
virtual const wchar_t *getText() const
{
return Text.c_str();
}
//! Sets the new caption of this element.
virtual void setToolTipText(const wchar_t *text)
{
ToolTipText = text;
}
//! Returns caption of this element.
virtual const core::stringw &getToolTipText() const
{
return ToolTipText;
}
//! Returns id. Can be used to identify the element.
virtual s32 getID() const
{
return ID;
}
//! Sets the id of this element
virtual void setID(s32 id)
{
ID = id;
}
//! Called if an event happened.
bool OnEvent(const SEvent &event) override
{
return Parent ? Parent->OnEvent(event) : false;
}
//! Brings a child to front
/** \return True if successful, false if not. */
virtual bool bringToFront(IGUIElement *child)
{
if (child->Parent != this)
return false;
if (std::next(child->ParentPos) == Children.end()) // already there
return true;
Children.erase(child->ParentPos);
child->ParentPos = Children.insert(Children.end(), child);
return true;
}
//! Moves a child to the back, so it's siblings are drawn on top of it
/** \return True if successful, false if not. */
virtual bool sendToBack(IGUIElement *child)
{
if (child->Parent != this)
return false;
if (child->ParentPos == Children.begin()) // already there
return true;
Children.erase(child->ParentPos);
child->ParentPos = Children.insert(Children.begin(), child);
return true;
}
//! Returns list with children of this element
virtual const std::list<IGUIElement *> &getChildren() const
{
return Children;
}
//! Finds the first element with the given id.
/** \param id: Id to search for.
\param searchchildren: Set this to true, if also children of this
element may contain the element with the searched id and they
should be searched too.
\return Returns the first element with the given id. If no element
with this id was found, 0 is returned. */
virtual IGUIElement *getElementFromId(s32 id, bool searchchildren = false) const
{
IGUIElement *e = 0;
for (auto child : Children) {
if (child->getID() == id)
return child;
if (searchchildren)
e = child->getElementFromId(id, true);
if (e)
return e;
}
return e;
}
//! returns true if the given element is a child of this one.
//! \param child: The child element to check
bool isMyChild(IGUIElement *child) const
{
if (!child)
return false;
do {
if (child->Parent)
child = child->Parent;
} while (child->Parent && child != this);
return child == this;
}
//! searches elements to find the closest next element to tab to
/** \param startOrder: The TabOrder of the current element, -1 if none
\param reverse: true if searching for a lower number
\param group: true if searching for a higher one
\param first: element with the highest/lowest known tab order depending on search direction
\param closest: the closest match, depending on tab order and direction
\param includeInvisible: includes invisible elements in the search (default=false)
\param includeDisabled: includes disabled elements in the search (default=false)
\return true if successfully found an element, false to continue searching/fail */
bool getNextElement(s32 startOrder, bool reverse, bool group,
IGUIElement *&first, IGUIElement *&closest, bool includeInvisible = false,
bool includeDisabled = false) const
{
// we'll stop searching if we find this number
s32 wanted = startOrder + (reverse ? -1 : 1);
if (wanted == -2)
wanted = 1073741824; // maximum s32
auto it = Children.begin();
s32 closestOrder, currentOrder;
while (it != Children.end()) {
// ignore invisible elements and their children
if (((*it)->isVisible() || includeInvisible) &&
(group == true || (*it)->isTabGroup() == false)) {
// ignore disabled, but children are checked (disabled is currently per element ignoring parent states)
if ((*it)->isEnabled() || includeDisabled) {
// only check tab stops and those with the same group status
if ((*it)->isTabStop() && ((*it)->isTabGroup() == group)) {
currentOrder = (*it)->getTabOrder();
// is this what we're looking for?
if (currentOrder == wanted) {
closest = *it;
return true;
}
// is it closer than the current closest?
if (closest) {
closestOrder = closest->getTabOrder();
if ((reverse && currentOrder > closestOrder && currentOrder < startOrder) || (!reverse && currentOrder < closestOrder && currentOrder > startOrder)) {
closest = *it;
}
} else if ((reverse && currentOrder < startOrder) || (!reverse && currentOrder > startOrder)) {
closest = *it;
}
// is it before the current first?
if (first) {
closestOrder = first->getTabOrder();
if ((reverse && closestOrder < currentOrder) || (!reverse && closestOrder > currentOrder)) {
first = *it;
}
} else {
first = *it;
}
}
}
// search within children
if ((*it)->getNextElement(startOrder, reverse, group, first, closest, includeInvisible, includeDisabled)) {
return true;
}
}
++it;
}
return false;
}
//! Returns the type of the gui element.
/** This is needed for the .NET wrapper but will be used
later for serializing and deserializing.
If you wrote your own GUIElements, you need to set the type for your element as first parameter
in the constructor of IGUIElement. For own (=unknown) elements, simply use EGUIET_ELEMENT as type */
EGUI_ELEMENT_TYPE getType() const
{
return Type;
}
//! Returns true if the gui element supports the given type.
/** This is mostly used to check if you can cast a gui element to the class that goes with the type.
Most gui elements will only support their own type, but if you derive your own classes from interfaces
you can overload this function and add a check for the type of the base-class additionally.
This allows for checks comparable to the dynamic_cast of c++ with enabled rtti.
Note that you can't do that by calling BaseClass::hasType(type), but you have to do an explicit
comparison check, because otherwise the base class usually just checks for the member variable
Type which contains the type of your derived class.
*/
virtual bool hasType(EGUI_ELEMENT_TYPE type) const
{
return type == Type;
}
//! Returns the type name of the gui element.
/** This is needed serializing elements. */
virtual const c8 *getTypeName() const
{
return GUIElementTypeNames[Type];
}
//! Returns the name of the element.
/** \return Name as character string. */
virtual const c8 *getName() const
{
return Name.c_str();
}
//! Sets the name of the element.
/** \param name New name of the gui element. */
virtual void setName(const c8 *name)
{
Name = name;
}
//! Sets the name of the element.
/** \param name New name of the gui element. */
virtual void setName(const core::stringc &name)
{
Name = name;
}
//! Returns whether the element takes input from the IME
virtual bool acceptsIME()
{
return false;
}
protected:
// not virtual because needed in constructor
void addChildToEnd(IGUIElement *child)
{
if (child) {
child->grab(); // prevent destruction when removed
child->remove(); // remove from old parent
child->LastParentRect = getAbsolutePosition();
child->Parent = this;
child->ParentPos = Children.insert(Children.end(), child);
}
}
#ifndef NDEBUG
template <typename Iterator>
static size_t _fastSetChecksum(Iterator begin, Iterator end)
{
std::hash<typename Iterator::value_type> hasher;
size_t checksum = 0;
for (Iterator it = begin; it != end; ++it) {
size_t h = hasher(*it);
checksum ^= 966073049 + (h * 3432918353) + ((h >> 16) * 461845907);
}
return checksum;
}
#endif
// Reorder children [from, to) to the order given by `neworder`
void reorderChildren(
std::list<IGUIElement *>::iterator from,
std::list<IGUIElement *>::iterator to,
const std::vector<IGUIElement *> &neworder)
{
assert(_fastSetChecksum(from, to) == _fastSetChecksum(neworder.begin(), neworder.end()));
for (auto e : neworder) {
*from = e;
e->ParentPos = from;
++from;
}
assert(from == to);
}
// not virtual because needed in constructor
void recalculateAbsolutePosition(bool recursive)
{
core::rect<s32> parentAbsolute(0, 0, 0, 0);
core::rect<s32> parentAbsoluteClip;
f32 fw = 0.f, fh = 0.f;
if (Parent) {
parentAbsolute = Parent->AbsoluteRect;
if (NoClip) {
IGUIElement *p = this;
while (p->Parent)
p = p->Parent;
parentAbsoluteClip = p->AbsoluteClippingRect;
} else
parentAbsoluteClip = Parent->AbsoluteClippingRect;
}
const s32 diffx = parentAbsolute.getWidth() - LastParentRect.getWidth();
const s32 diffy = parentAbsolute.getHeight() - LastParentRect.getHeight();
if (AlignLeft == EGUIA_SCALE || AlignRight == EGUIA_SCALE)
fw = (f32)parentAbsolute.getWidth();
if (AlignTop == EGUIA_SCALE || AlignBottom == EGUIA_SCALE)
fh = (f32)parentAbsolute.getHeight();
switch (AlignLeft) {
case EGUIA_UPPERLEFT:
break;
case EGUIA_LOWERRIGHT:
DesiredRect.UpperLeftCorner.X += diffx;
break;
case EGUIA_CENTER:
DesiredRect.UpperLeftCorner.X += diffx / 2;
break;
case EGUIA_SCALE:
DesiredRect.UpperLeftCorner.X = core::round32(ScaleRect.UpperLeftCorner.X * fw);
break;
}
switch (AlignRight) {
case EGUIA_UPPERLEFT:
break;
case EGUIA_LOWERRIGHT:
DesiredRect.LowerRightCorner.X += diffx;
break;
case EGUIA_CENTER:
DesiredRect.LowerRightCorner.X += diffx / 2;
break;
case EGUIA_SCALE:
DesiredRect.LowerRightCorner.X = core::round32(ScaleRect.LowerRightCorner.X * fw);
break;
}
switch (AlignTop) {
case EGUIA_UPPERLEFT:
break;
case EGUIA_LOWERRIGHT:
DesiredRect.UpperLeftCorner.Y += diffy;
break;
case EGUIA_CENTER:
DesiredRect.UpperLeftCorner.Y += diffy / 2;
break;
case EGUIA_SCALE:
DesiredRect.UpperLeftCorner.Y = core::round32(ScaleRect.UpperLeftCorner.Y * fh);
break;
}
switch (AlignBottom) {
case EGUIA_UPPERLEFT:
break;
case EGUIA_LOWERRIGHT:
DesiredRect.LowerRightCorner.Y += diffy;
break;
case EGUIA_CENTER:
DesiredRect.LowerRightCorner.Y += diffy / 2;
break;
case EGUIA_SCALE:
DesiredRect.LowerRightCorner.Y = core::round32(ScaleRect.LowerRightCorner.Y * fh);
break;
}
RelativeRect = DesiredRect;
const s32 w = RelativeRect.getWidth();
const s32 h = RelativeRect.getHeight();
// make sure the desired rectangle is allowed
if (w < (s32)MinSize.Width)
RelativeRect.LowerRightCorner.X = RelativeRect.UpperLeftCorner.X + MinSize.Width;
if (h < (s32)MinSize.Height)
RelativeRect.LowerRightCorner.Y = RelativeRect.UpperLeftCorner.Y + MinSize.Height;
if (MaxSize.Width && w > (s32)MaxSize.Width)
RelativeRect.LowerRightCorner.X = RelativeRect.UpperLeftCorner.X + MaxSize.Width;
if (MaxSize.Height && h > (s32)MaxSize.Height)
RelativeRect.LowerRightCorner.Y = RelativeRect.UpperLeftCorner.Y + MaxSize.Height;
RelativeRect.repair();
AbsoluteRect = RelativeRect + parentAbsolute.UpperLeftCorner;
if (!Parent)
parentAbsoluteClip = AbsoluteRect;
AbsoluteClippingRect = AbsoluteRect;
AbsoluteClippingRect.clipAgainst(parentAbsoluteClip);
LastParentRect = parentAbsolute;
if (recursive) {
// update all children
for (auto child : Children) {
child->recalculateAbsolutePosition(recursive);
}
}
}
protected:
//! List of all children of this element
std::list<IGUIElement *> Children;
//! Pointer to the parent
IGUIElement *Parent;
//! Our position in the parent list. Only valid when Parent != nullptr
std::list<IGUIElement *>::iterator ParentPos;
//! relative rect of element
core::rect<s32> RelativeRect;
//! absolute rect of element
core::rect<s32> AbsoluteRect;
//! absolute clipping rect of element
core::rect<s32> AbsoluteClippingRect;
//! the rectangle the element would prefer to be,
//! if it was not constrained by parent or max/min size
core::rect<s32> DesiredRect;
//! for calculating the difference when resizing parent
core::rect<s32> LastParentRect;
//! relative scale of the element inside its parent
core::rect<f32> ScaleRect;
//! maximum and minimum size of the element
core::dimension2du MaxSize, MinSize;
//! is visible?
bool IsVisible;
//! is enabled?
bool IsEnabled;
//! is a part of a larger whole and should not be serialized?
bool IsSubElement;
//! does this element ignore its parent's clipping rectangle?
bool NoClip;
//! caption
core::stringw Text;
//! tooltip
core::stringw ToolTipText;
//! users can set this for identifying the element by string
core::stringc Name;
//! users can set this for identifying the element by integer
s32 ID;
//! tab stop like in windows
bool IsTabStop;
//! tab order
s32 TabOrder;
//! tab groups are containers like windows, use ctrl+tab to navigate
bool IsTabGroup;
//! tells the element how to act when its parent is resized
EGUI_ALIGNMENT AlignLeft, AlignRight, AlignTop, AlignBottom;
//! GUI Environment
IGUIEnvironment *Environment;
//! type of element
EGUI_ELEMENT_TYPE Type;
};
} // end namespace gui
} // end namespace irr

414
irr/include/IGUIEnvironment.h Normal file
View File

@ -0,0 +1,414 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "IGUISkin.h"
#include "rect.h"
#include "EFocusFlags.h"
#include "IEventReceiver.h"
#include "path.h"
namespace irr
{
class IOSOperator;
class IEventReceiver;
namespace io
{
class IReadFile;
class IWriteFile;
class IFileSystem;
} // end namespace io
namespace video
{
class IVideoDriver;
class ITexture;
} // end namespace video
namespace gui
{
class IGUIElement;
class IGUIFont;
class IGUISpriteBank;
class IGUIScrollBar;
class IGUIImage;
class IGUICheckBox;
class IGUIListBox;
class IGUIImageList;
class IGUIFileOpenDialog;
class IGUIStaticText;
class IGUIEditBox;
class IGUITabControl;
class IGUITab;
class IGUIComboBox;
class IGUIButton;
class IGUIWindow;
//! GUI Environment. Used as factory and manager of all other GUI elements.
/** \par This element can create the following events of type EGUI_EVENT_TYPE (which are passed on to focused sub-elements):
\li EGET_ELEMENT_FOCUS_LOST
\li EGET_ELEMENT_FOCUSED
\li EGET_ELEMENT_LEFT
\li EGET_ELEMENT_HOVERED
*/
class IGUIEnvironment : public virtual IReferenceCounted
{
public:
//! Draws all gui elements by traversing the GUI environment starting at the root node.
/** \param When true ensure the GuiEnvironment (aka the RootGUIElement) has the same size as the current driver screensize.
Can be set to false to control that size yourself, p.E when not the full size should be used for UI. */
virtual void drawAll(bool useScreenSize = true) = 0;
//! Sets the focus to an element.
/** Causes a EGET_ELEMENT_FOCUS_LOST event followed by a
EGET_ELEMENT_FOCUSED event. If someone absorbed either of the events,
then the focus will not be changed.
\param element Pointer to the element which shall get the focus.
\return True on success, false on failure */
virtual bool setFocus(IGUIElement *element) = 0;
//! Returns the element which holds the focus.
/** \return Pointer to the element with focus. */
virtual IGUIElement *getFocus() const = 0;
//! Returns the element which was last under the mouse cursor
/** NOTE: This information is updated _after_ the user-eventreceiver
received it's mouse-events. To find the hovered element while catching
mouse events you have to use instead:
IGUIEnvironment::getRootGUIElement()->getElementFromPoint(mousePos);
\return Pointer to the element under the mouse. */
virtual IGUIElement *getHovered() const = 0;
//! Removes the focus from an element.
/** Causes a EGET_ELEMENT_FOCUS_LOST event. If the event is absorbed
then the focus will not be changed.
\param element Pointer to the element which shall lose the focus.
\return True on success, false on failure */
virtual bool removeFocus(IGUIElement *element) = 0;
//! Returns whether the element has focus
/** \param element Pointer to the element which is tested.
\param checkSubElements When true and focus is on a sub-element of element then it will still count as focused and return true
\return True if the element has focus, else false. */
virtual bool hasFocus(const IGUIElement *element, bool checkSubElements = false) const = 0;
//! Returns the current video driver.
/** \return Pointer to the video driver. */
virtual video::IVideoDriver *getVideoDriver() const = 0;
//! Returns the file system.
/** \return Pointer to the file system. */
virtual io::IFileSystem *getFileSystem() const = 0;
//! returns a pointer to the OS operator
/** \return Pointer to the OS operator. */
virtual IOSOperator *getOSOperator() const = 0;
//! Removes all elements from the environment.
virtual void clear() = 0;
//! Posts an input event to the environment.
/** Usually you do not have to
use this method, it is used by the engine internally.
\param event The event to post.
\return True if succeeded, else false. */
virtual bool postEventFromUser(const SEvent &event) = 0;
//! This sets a new event receiver for gui events.
/** Usually you do not have to
use this method, it is used by the engine internally.
\param evr Pointer to the new receiver. */
virtual void setUserEventReceiver(IEventReceiver *evr) = 0;
//! Returns pointer to the current gui skin.
/** \return Pointer to the GUI skin. */
virtual IGUISkin *getSkin() const = 0;
//! Sets a new GUI Skin
/** You can use this to change the appearance of the whole GUI
Environment. You can set one of the built-in skins or implement your
own class derived from IGUISkin and enable it using this method.
To set for example the built-in Windows classic skin, use the following
code:
\code
gui::IGUISkin* newskin = environment->createSkin(gui::EGST_WINDOWS_CLASSIC);
environment->setSkin(newskin);
newskin->drop();
\endcode
\param skin New skin to use.
*/
virtual void setSkin(IGUISkin *skin) = 0;
//! Creates a new GUI Skin based on a template.
/** Use setSkin() to set the created skin.
\param type The type of the new skin.
\return Pointer to the created skin.
If you no longer need it, you should call IGUISkin::drop().
See IReferenceCounted::drop() for more information. */
virtual IGUISkin *createSkin(EGUI_SKIN_TYPE type) = 0;
//! Creates the image list from the given texture.
/** \param texture Texture to split into images
\param imageSize Dimension of each image
\param useAlphaChannel Flag whether alpha channel of the texture should be honored.
\return Pointer to the font. Returns 0 if the font could not be loaded.
This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */
virtual IGUIImageList *createImageList(video::ITexture *texture,
core::dimension2d<s32> imageSize,
bool useAlphaChannel) = 0;
//! Returns pointer to the font with the specified filename.
/** Loads the font if it was not loaded before.
\param filename Filename of the Font.
\return Pointer to the font. Returns 0 if the font could not be loaded.
This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */
virtual IGUIFont *getFont(const io::path &filename) = 0;
//! Adds an externally loaded font to the font list.
/** This method allows to attach an already loaded font to the list of
existing fonts. The font is grabbed if non-null and adding was successful.
\param name Name the font should be stored as.
\param font Pointer to font to add.
\return Pointer to the font stored. This can differ from given parameter if the name previously existed. */
virtual IGUIFont *addFont(const io::path &name, IGUIFont *font) = 0;
//! remove loaded font
virtual void removeFont(IGUIFont *font) = 0;
//! Returns the default built-in font.
/** \return Pointer to the default built-in font.
This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */
virtual IGUIFont *getBuiltInFont() const = 0;
//! Returns pointer to the sprite bank which was added with addEmptySpriteBank
/** TODO: This should load files in the future, but not implemented so far.
\param filename Name of a spritebank added with addEmptySpriteBank
\return Pointer to the sprite bank. Returns 0 if it could not be loaded.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual IGUISpriteBank *getSpriteBank(const io::path &filename) = 0;
//! Adds an empty sprite bank to the manager
/** \param name Name of the new sprite bank.
\return Pointer to the sprite bank.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual IGUISpriteBank *addEmptySpriteBank(const io::path &name) = 0;
//! Returns the root gui element.
/** This is the first gui element, the (direct or indirect) parent of all
other gui elements. It is a valid IGUIElement, with dimensions the same
size as the screen.
\return Pointer to the root element of the GUI. The returned pointer
should not be dropped. See IReferenceCounted::drop() for more
information. */
virtual IGUIElement *getRootGUIElement() = 0;
//! Adds a button element.
/** \param rectangle Rectangle specifying the borders of the button.
\param parent Parent gui element of the button.
\param id Id with which the gui element can be identified.
\param text Text displayed on the button.
\param tooltiptext Text displayed in the tooltip.
\return Pointer to the created button. Returns 0 if an error occurred.
This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */
virtual IGUIButton *addButton(const core::rect<s32> &rectangle,
IGUIElement *parent = 0, s32 id = -1, const wchar_t *text = 0, const wchar_t *tooltiptext = 0) = 0;
//! Adds a scrollbar.
/** \param horizontal Specifies if the scroll bar is drawn horizontal
or vertical.
\param rectangle Rectangle specifying the borders of the scrollbar.
\param parent Parent gui element of the scroll bar.
\param id Id to identify the gui element.
\return Pointer to the created scrollbar. Returns 0 if an error
occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */
virtual IGUIScrollBar *addScrollBar(bool horizontal, const core::rect<s32> &rectangle,
IGUIElement *parent = 0, s32 id = -1) = 0;
//! Adds an image element.
/** \param image Image to be displayed.
\param pos Position of the image. The width and height of the image is
taken from the image.
\param useAlphaChannel Sets if the image should use the alpha channel
of the texture to draw itself.
\param parent Parent gui element of the image.
\param id Id to identify the gui element.
\param text Title text of the image (not displayed).
\return Pointer to the created image element. Returns 0 if an error
occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */
virtual IGUIImage *addImage(video::ITexture *image, core::position2d<s32> pos,
bool useAlphaChannel = true, IGUIElement *parent = 0, s32 id = -1, const wchar_t *text = 0) = 0;
//! Adds an image element.
/** Use IGUIImage::setImage later to set the image to be displayed.
\param rectangle Rectangle specifying the borders of the image.
\param parent Parent gui element of the image.
\param id Id to identify the gui element.
\param text Title text of the image (not displayed).
\param useAlphaChannel Sets if the image should use the alpha channel
of the texture to draw itself.
\return Pointer to the created image element. Returns 0 if an error
occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */
virtual IGUIImage *addImage(const core::rect<s32> &rectangle,
IGUIElement *parent = 0, s32 id = -1, const wchar_t *text = 0, bool useAlphaChannel = true) = 0;
//! Adds a checkbox element.
/** \param checked Define the initial state of the check box.
\param rectangle Rectangle specifying the borders of the check box.
\param parent Parent gui element of the check box.
\param id Id to identify the gui element.
\param text Title text of the check box.
\return Pointer to the created check box. Returns 0 if an error
occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */
virtual IGUICheckBox *addCheckBox(bool checked, const core::rect<s32> &rectangle,
IGUIElement *parent = 0, s32 id = -1, const wchar_t *text = 0) = 0;
//! Adds a list box element.
/** \param rectangle Rectangle specifying the borders of the list box.
\param parent Parent gui element of the list box.
\param id Id to identify the gui element.
\param drawBackground Flag whether the background should be drawn.
\return Pointer to the created list box. Returns 0 if an error occurred.
This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */
virtual IGUIListBox *addListBox(const core::rect<s32> &rectangle,
IGUIElement *parent = 0, s32 id = -1, bool drawBackground = false) = 0;
//! Adds a file open dialog.
/** \param title Text to be displayed as the title of the dialog.
\param modal Defines if the dialog is modal. This means, that all other
gui elements which were created before the message box cannot be used
until this messagebox is removed.
\param parent Parent gui element of the dialog.
\param id Id to identify the gui element.
\param restoreCWD If set to true, the current working directory will be
restored after the dialog is closed in some way. Otherwise the working
directory will be the one that the file dialog was last showing.
\param startDir Optional path for which the file dialog will be opened.
\return Pointer to the created file open dialog. Returns 0 if an error
occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */
virtual IGUIFileOpenDialog *addFileOpenDialog(const wchar_t *title = 0,
bool modal = true, IGUIElement *parent = 0, s32 id = -1,
bool restoreCWD = false, io::path::char_type *startDir = 0) = 0;
//! Adds a static text.
/** \param text Text to be displayed. Can be altered after creation by SetText().
\param rectangle Rectangle specifying the borders of the static text
\param border Set to true if the static text should have a 3d border.
\param wordWrap Enable if the text should wrap into multiple lines.
\param parent Parent item of the element, e.g. a window.
\param id The ID of the element.
\param fillBackground Enable if the background shall be filled.
Defaults to false.
\return Pointer to the created static text. Returns 0 if an error
occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */
virtual IGUIStaticText *addStaticText(const wchar_t *text, const core::rect<s32> &rectangle,
bool border = false, bool wordWrap = true, IGUIElement *parent = 0, s32 id = -1,
bool fillBackground = false) = 0;
//! Adds an edit box.
/** Supports Unicode input from every keyboard around the world,
scrolling, copying and pasting (exchanging data with the clipboard
directly), maximum character amount, marking, and all shortcuts like
ctrl+X, ctrl+V, ctrl+C, shift+Left, shift+Right, Home, End, and so on.
\param text Text to be displayed. Can be altered after creation
by setText().
\param rectangle Rectangle specifying the borders of the edit box.
\param border Set to true if the edit box should have a 3d border.
\param parent Parent item of the element, e.g. a window.
Set it to 0 to place the edit box directly in the environment.
\param id The ID of the element.
\return Pointer to the created edit box. Returns 0 if an error occurred.
This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */
virtual IGUIEditBox *addEditBox(const wchar_t *text, const core::rect<s32> &rectangle,
bool border = true, IGUIElement *parent = 0, s32 id = -1) = 0;
//! Adds a tab control to the environment.
/** \param rectangle Rectangle specifying the borders of the tab control.
\param parent Parent item of the element, e.g. a window.
Set it to 0 to place the tab control directly in the environment.
\param fillbackground Specifies if the background of the tab control
should be drawn.
\param border Specifies if a flat 3d border should be drawn. This is
usually not necessary unless you place the control directly into
the environment without a window as parent.
\param id An identifier for the tab control.
\return Pointer to the created tab control element. Returns 0 if an
error occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */
virtual IGUITabControl *addTabControl(const core::rect<s32> &rectangle,
IGUIElement *parent = 0, bool fillbackground = false,
bool border = true, s32 id = -1) = 0;
//! Adds tab to the environment.
/** You can use this element to group other elements. This is not used
for creating tabs on tab controls, please use IGUITabControl::addTab()
for this instead.
\param rectangle Rectangle specifying the borders of the tab.
\param parent Parent item of the element, e.g. a window.
Set it to 0 to place the tab directly in the environment.
\param id An identifier for the tab.
\return Pointer to the created tab. Returns 0 if an
error occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */
virtual IGUITab *addTab(const core::rect<s32> &rectangle,
IGUIElement *parent = 0, s32 id = -1) = 0;
//! Adds a combo box to the environment.
/** \param rectangle Rectangle specifying the borders of the combo box.
\param parent Parent item of the element, e.g. a window.
Set it to 0 to place the combo box directly in the environment.
\param id An identifier for the combo box.
\return Pointer to the created combo box. Returns 0 if an
error occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */
virtual IGUIComboBox *addComboBox(const core::rect<s32> &rectangle,
IGUIElement *parent = 0, s32 id = -1) = 0;
//! Find the next element which would be selected when pressing the tab-key
/** If you set the focus for the result you can manually force focus-changes like they
would happen otherwise by the tab-keys.
\param reverse When true it will search backward (toward lower TabOrder numbers, like shift+tab)
\param group When true it will search for the next tab-group (like ctrl+tab)
*/
virtual IGUIElement *getNextElement(bool reverse = false, bool group = false) = 0;
//! Set the way the gui will handle automatic focus changes
/** The default is (EFF_SET_ON_LMOUSE_DOWN | EFF_SET_ON_TAB).
with the left mouse button.
This does not affect the setFocus function itself - users can still call that whenever they want on any element.
\param flags A bitmask which is a combination of ::EFOCUS_FLAG flags.*/
virtual void setFocusBehavior(u32 flags) = 0;
//! Get the way the gui does handle focus changes
/** \returns A bitmask which is a combination of ::EFOCUS_FLAG flags.*/
virtual u32 getFocusBehavior() const = 0;
//! Adds a IGUIElement to deletion queue.
/** Queued elements will be removed at the end of each drawAll call.
Or latest in the destructor of the GUIEnvironment.
This can be used to allow an element removing itself safely in a function
iterating over gui elements, like an overloaded IGUIElement::draw or
IGUIElement::OnPostRender function.
Note that in general just calling IGUIElement::remove() is enough.
Unless you create your own GUI elements removing themselves you won't need it.
\param element: Element to remove */
virtual void addToDeletionQueue(IGUIElement *element) = 0;
};
} // end namespace gui
} // end namespace irr

44
irr/include/IGUIFileOpenDialog.h Normal file
View File

@ -0,0 +1,44 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIElement.h"
#include "path.h"
namespace irr
{
namespace gui
{
//! Standard file chooser dialog.
/** \warning When the user selects a folder this does change the current working directory
\par This element can create the following events of type EGUI_EVENT_TYPE:
\li EGET_DIRECTORY_SELECTED
\li EGET_FILE_SELECTED
\li EGET_FILE_CHOOSE_DIALOG_CANCELLED
*/
class IGUIFileOpenDialog : public IGUIElement
{
public:
//! constructor
IGUIFileOpenDialog(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_FILE_OPEN_DIALOG, environment, parent, id, rectangle) {}
//! Returns the filename of the selected file converted to wide characters. Returns NULL if no file was selected.
virtual const wchar_t *getFileName() const = 0;
//! Returns the filename of the selected file. Is empty if no file was selected.
virtual const io::path &getFileNameP() const = 0;
//! Returns the directory of the selected file. Empty if no directory was selected.
virtual const io::path &getDirectoryName() const = 0;
//! Returns the directory of the selected file converted to wide characters. Returns NULL if no directory was selected.
virtual const wchar_t *getDirectoryNameW() const = 0;
};
} // end namespace gui
} // end namespace irr

99
irr/include/IGUIFont.h Normal file
View File

@ -0,0 +1,99 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "SColor.h"
#include "rect.h"
#include "irrString.h"
namespace irr
{
namespace gui
{
//! An enum for the different types of GUI font.
enum EGUI_FONT_TYPE
{
//! Bitmap fonts loaded from an XML file or a texture.
EGFT_BITMAP = 0,
//! Scalable vector fonts loaded from an XML file.
/** These fonts reside in system memory and use no video memory
until they are displayed. These are slower than bitmap fonts
but can be easily scaled and rotated. */
EGFT_VECTOR,
//! A font which uses a the native API provided by the operating system.
/** Currently not used. */
EGFT_OS,
//! An external font type provided by the user.
EGFT_CUSTOM
};
//! Font interface.
class IGUIFont : public virtual IReferenceCounted
{
public:
//! Draws some text and clips it to the specified rectangle if wanted.
/** \param text: Text to draw
\param position: Rectangle specifying position where to draw the text.
\param color: Color of the text
\param hcenter: Specifies if the text should be centered horizontally into the rectangle.
\param vcenter: Specifies if the text should be centered vertically into the rectangle.
\param clip: Optional pointer to a rectangle against which the text will be clipped.
If the pointer is null, no clipping will be done. */
virtual void draw(const core::stringw &text, const core::rect<s32> &position,
video::SColor color, bool hcenter = false, bool vcenter = false,
const core::rect<s32> *clip = 0) = 0;
//! Calculates the width and height of a given string of text.
/** \return Returns width and height of the area covered by the text if
it would be drawn. */
virtual core::dimension2d<u32> getDimension(const wchar_t *text) const = 0;
//! Calculates the index of the character in the text which is on a specific position.
/** \param text: Text string.
\param pixel_x: X pixel position of which the index of the character will be returned.
\return Returns zero based index of the character in the text, and -1 if no no character
is on this position. (=the text is too short). */
virtual s32 getCharacterFromPos(const wchar_t *text, s32 pixel_x) const = 0;
//! Returns the type of this font
virtual EGUI_FONT_TYPE getType() const { return EGFT_CUSTOM; }
//! Sets global kerning width for the font.
virtual void setKerningWidth(s32 kerning) = 0;
//! Sets global kerning height for the font.
virtual void setKerningHeight(s32 kerning) = 0;
//! Gets kerning values (distance between letters) for the font. If no parameters are provided,
/** the global kerning distance is returned.
\param thisLetter: If this parameter is provided, the left side kerning
for this letter is added to the global kerning value. For example, a
space might only be one pixel wide, but it may be displayed as several
pixels.
\param previousLetter: If provided, kerning is calculated for both
letters and added to the global kerning value. For example, in a font
which supports kerning pairs a string such as 'Wo' may have the 'o'
tucked neatly under the 'W'.
*/
virtual s32 getKerningWidth(const wchar_t *thisLetter = 0, const wchar_t *previousLetter = 0) const = 0;
//! Returns the distance between letters
virtual s32 getKerningHeight() const = 0;
//! Define which characters should not be drawn by the font.
/** For example " " would not draw any space which is usually blank in
most fonts.
\param s String of symbols which are not send down to the videodriver
*/
virtual void setInvisibleCharacters(const wchar_t *s) = 0;
};
} // end namespace gui
} // end namespace irr

41
irr/include/IGUIFontBitmap.h Normal file
View File

@ -0,0 +1,41 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIFont.h"
namespace irr
{
namespace gui
{
class IGUISpriteBank;
//! Font interface.
class IGUIFontBitmap : public IGUIFont
{
public:
//! Returns the type of this font
EGUI_FONT_TYPE getType() const override { return EGFT_BITMAP; }
//! returns the parsed Symbol Information
virtual IGUISpriteBank *getSpriteBank() const = 0;
//! returns the sprite number from a given character
virtual u32 getSpriteNoFromChar(const wchar_t *c) const = 0;
//! Gets kerning values (distance between letters) for the font. If no parameters are provided,
/** the global kerning distance is returned.
\param thisLetter: If this parameter is provided, the left side kerning for this letter is added
to the global kerning value. For example, a space might only be one pixel wide, but it may
be displayed as several pixels.
\param previousLetter: If provided, kerning is calculated for both letters and added to the global
kerning value. For example, EGFT_BITMAP will add the right kerning value of previousLetter to the
left side kerning value of thisLetter, then add the global value.
*/
s32 getKerningWidth(const wchar_t *thisLetter = 0, const wchar_t *previousLetter = 0) const override = 0;
};
} // end namespace gui
} // end namespace irr

82
irr/include/IGUIImage.h Normal file
View File

@ -0,0 +1,82 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIElement.h"
namespace irr
{
namespace video
{
class ITexture;
}
namespace gui
{
//! GUI element displaying an image.
class IGUIImage : public IGUIElement
{
public:
//! constructor
IGUIImage(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_IMAGE, environment, parent, id, rectangle) {}
//! Sets an image texture
virtual void setImage(video::ITexture *image) = 0;
//! Gets the image texture
virtual video::ITexture *getImage() const = 0;
//! Sets the color of the image
/** \param color Color with which the image is drawn. If the color
equals Color(255,255,255,255) it is ignored. */
virtual void setColor(video::SColor color) = 0;
//! Sets if the image should scale to fit the element
virtual void setScaleImage(bool scale) = 0;
//! Sets if the image should use its alpha channel to draw itself
virtual void setUseAlphaChannel(bool use) = 0;
//! Gets the color of the image
virtual video::SColor getColor() const = 0;
//! Returns true if the image is scaled to fit, false if not
virtual bool isImageScaled() const = 0;
//! Returns true if the image is using the alpha channel, false if not
virtual bool isAlphaChannelUsed() const = 0;
//! Sets the source rectangle of the image. By default the full image is used.
/** \param sourceRect coordinates inside the image or an area with size 0 for using the full image (default). */
virtual void setSourceRect(const core::rect<s32> &sourceRect) = 0;
//! Returns the customized source rectangle of the image to be used.
/** By default an empty rectangle of width and height 0 is returned which means the full image is used. */
virtual core::rect<s32> getSourceRect() const = 0;
//! Restrict drawing-area.
/** This allows for example to use the image as a progress bar.
Base for area is the image, which means:
- The original clipping area when the texture is scaled or there is no texture.
- The source-rect for an unscaled texture (but still restricted afterward by the clipping area)
Unlike normal clipping this does not affect the gui-children.
\param drawBoundUVs: Coordinates between 0 and 1 where 0 are for left+top and 1 for right+bottom
*/
virtual void setDrawBounds(const core::rect<f32> &drawBoundUVs = core::rect<f32>(0.f, 0.f, 1.f, 1.f)) = 0;
//! Get drawing-area restrictions.
virtual core::rect<f32> getDrawBounds() const = 0;
//! Sets whether to draw a background color (EGDC_3D_DARK_SHADOW) when no texture is set
/** By default it's enabled */
virtual void setDrawBackground(bool draw) = 0;
//! Checks if a background is drawn when no texture is set
/** \return true if background drawing is enabled, false otherwise */
virtual bool isDrawBackgroundEnabled() const = 0;
};
} // end namespace gui
} // end namespace irr

40
irr/include/IGUIImageList.h Normal file
View File

@ -0,0 +1,40 @@
// This file is part of the "Irrlicht Engine".
// written by Reinhard Ostermeier, reinhard@nospam.r-ostermeier.de
#pragma once
#include "IGUIElement.h"
#include "rect.h"
#include "irrTypes.h"
namespace irr
{
namespace gui
{
//! Font interface.
class IGUIImageList : public virtual IReferenceCounted
{
public:
//! Destructor
virtual ~IGUIImageList(){};
//! Draws an image and clips it to the specified rectangle if wanted
//! \param index: Index of the image
//! \param destPos: Position of the image to draw
//! \param clip: Optional pointer to a rectangle against which the text will be clipped.
//! If the pointer is null, no clipping will be done.
virtual void draw(s32 index, const core::position2d<s32> &destPos,
const core::rect<s32> *clip = 0) = 0;
//! Returns the count of Images in the list.
//! \return Returns the count of Images in the list.
virtual s32 getImageCount() const = 0;
//! Returns the size of the images in the list.
//! \return Returns the size of the images in the list.
virtual core::dimension2d<s32> getImageSize() const = 0;
};
} // end namespace gui
} // end namespace irr

136
irr/include/IGUIListBox.h Normal file
View File

@ -0,0 +1,136 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIElement.h"
#include "SColor.h"
namespace irr
{
namespace gui
{
class IGUISpriteBank;
class IGUIScrollBar;
//! Enumeration for listbox colors
enum EGUI_LISTBOX_COLOR
{
//! Color of text
EGUI_LBC_TEXT = 0,
//! Color of selected text
EGUI_LBC_TEXT_HIGHLIGHT,
//! Color of icon
EGUI_LBC_ICON,
//! Color of selected icon
EGUI_LBC_ICON_HIGHLIGHT,
//! Not used, just counts the number of available colors
EGUI_LBC_COUNT
};
//! Default list box GUI element.
/** \par This element can create the following events of type EGUI_EVENT_TYPE:
\li EGET_LISTBOX_CHANGED
\li EGET_LISTBOX_SELECTED_AGAIN
*/
class IGUIListBox : public IGUIElement
{
public:
//! constructor
IGUIListBox(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_LIST_BOX, environment, parent, id, rectangle) {}
//! returns amount of list items
virtual u32 getItemCount() const = 0;
//! returns string of a list item. the may id be a value from 0 to itemCount-1
virtual const wchar_t *getListItem(u32 id) const = 0;
//! adds an list item, returns id of item
virtual u32 addItem(const wchar_t *text) = 0;
//! adds an list item with an icon
/** \param text Text of list entry
\param icon Sprite index of the Icon within the current sprite bank. Set it to -1 if you want no icon
\return The id of the new created item */
virtual u32 addItem(const wchar_t *text, s32 icon) = 0;
//! Removes an item from the list
virtual void removeItem(u32 index) = 0;
//! get the the id of the item at the given absolute coordinates
/** \return The id of the list item or -1 when no item is at those coordinates*/
virtual s32 getItemAt(s32 xpos, s32 ypos) const = 0;
//! Returns the icon of an item
virtual s32 getIcon(u32 index) const = 0;
//! Sets the sprite bank which should be used to draw list icons.
/** This font is set to the sprite bank of the built-in-font by
default. A sprite can be displayed in front of every list item.
An icon is an index within the icon sprite bank. Several
default icons are available in the skin through getIcon. */
virtual void setSpriteBank(IGUISpriteBank *bank) = 0;
//! clears the list, deletes all items in the listbox
virtual void clear() = 0;
//! returns id of selected item. returns -1 if no item is selected.
virtual s32 getSelected() const = 0;
//! sets the selected item. Set this to -1 if no item should be selected
virtual void setSelected(s32 index) = 0;
//! sets the selected item. Set this to 0 if no item should be selected
virtual void setSelected(const wchar_t *item) = 0;
//! set whether the listbox should scroll to newly selected items
virtual void setAutoScrollEnabled(bool scroll) = 0;
//! returns true if automatic scrolling is enabled, false if not.
virtual bool isAutoScrollEnabled() const = 0;
//! set all item colors at given index to color
virtual void setItemOverrideColor(u32 index, video::SColor color) = 0;
//! set all item colors of specified type at given index to color
virtual void setItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType, video::SColor color) = 0;
//! clear all item colors at index
virtual void clearItemOverrideColor(u32 index) = 0;
//! clear item color at index for given colortype
virtual void clearItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) = 0;
//! has the item at index its color overwritten?
virtual bool hasItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) const = 0;
//! return the overwrite color at given item index.
virtual video::SColor getItemOverrideColor(u32 index, EGUI_LISTBOX_COLOR colorType) const = 0;
//! return the default color which is used for the given colorType
virtual video::SColor getItemDefaultColor(EGUI_LISTBOX_COLOR colorType) const = 0;
//! set the item at the given index
virtual void setItem(u32 index, const wchar_t *text, s32 icon) = 0;
//! Insert the item at the given index
/** \return The index on success or -1 on failure. */
virtual s32 insertItem(u32 index, const wchar_t *text, s32 icon) = 0;
//! Swap the items at the given indices
virtual void swapItems(u32 index1, u32 index2) = 0;
//! set global itemHeight
virtual void setItemHeight(s32 height) = 0;
//! Sets whether to draw the background
virtual void setDrawBackground(bool draw) = 0;
//! Access the vertical scrollbar
virtual IGUIScrollBar *getVerticalScrollBar() const = 0;
};
} // end namespace gui
} // end namespace irr

59
irr/include/IGUIScrollBar.h Normal file
View File

@ -0,0 +1,59 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIElement.h"
namespace irr
{
namespace gui
{
//! Default scroll bar GUI element.
/** \par This element can create the following events of type EGUI_EVENT_TYPE:
\li EGET_SCROLL_BAR_CHANGED
*/
class IGUIScrollBar : public IGUIElement
{
public:
//! constructor
IGUIScrollBar(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_SCROLL_BAR, environment, parent, id, rectangle) {}
//! sets the maximum value of the scrollbar.
virtual void setMax(s32 max) = 0;
//! gets the maximum value of the scrollbar.
virtual s32 getMax() const = 0;
//! sets the minimum value of the scrollbar.
virtual void setMin(s32 min) = 0;
//! gets the minimum value of the scrollbar.
virtual s32 getMin() const = 0;
//! gets the small step value
virtual s32 getSmallStep() const = 0;
//! Sets the small step
/** That is the amount that the value changes by when clicking
on the buttons or using the cursor keys. */
virtual void setSmallStep(s32 step) = 0;
//! gets the large step value
virtual s32 getLargeStep() const = 0;
//! Sets the large step
/** That is the amount that the value changes by when clicking
in the tray, or using the page up and page down keys. */
virtual void setLargeStep(s32 step) = 0;
//! gets the current position of the scrollbar
virtual s32 getPos() const = 0;
//! sets the current position of the scrollbar
virtual void setPos(s32 pos) = 0;
};
} // end namespace gui
} // end namespace irr

565
irr/include/IGUISkin.h Normal file
View File

@ -0,0 +1,565 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "EGUIAlignment.h"
#include "SColor.h"
#include "rect.h"
namespace irr
{
namespace gui
{
class IGUIFont;
class IGUISpriteBank;
class IGUIElement;
//! Enumeration of available default skins.
/** To set one of the skins, use the following code, for example to set
the Windows classic skin:
\code
gui::IGUISkin* newskin = environment->createSkin(gui::EGST_WINDOWS_CLASSIC);
environment->setSkin(newskin);
newskin->drop();
\endcode
*/
enum EGUI_SKIN_TYPE
{
//! Default windows look and feel
EGST_WINDOWS_CLASSIC = 0,
//! Like EGST_WINDOWS_CLASSIC, but with metallic shaded windows and buttons
EGST_WINDOWS_METALLIC,
//! Burning's skin
EGST_BURNING_SKIN,
//! An unknown skin, not serializable at present
EGST_UNKNOWN,
//! this value is not used, it only specifies the number of skin types
EGST_COUNT
};
//! Names for gui element types
const c8 *const GUISkinTypeNames[EGST_COUNT + 1] = {
"windowsClassic",
"windowsMetallic",
"burning",
"unknown",
0,
};
//! Enumeration for skin colors
enum EGUI_DEFAULT_COLOR
{
//! Dark shadow for three-dimensional display elements.
EGDC_3D_DARK_SHADOW = 0,
//! Shadow color for three-dimensional display elements (for edges facing away from the light source).
EGDC_3D_SHADOW,
//! Face color for three-dimensional display elements and for dialog box backgrounds.
EGDC_3D_FACE,
//! Highlight color for three-dimensional display elements (for edges facing the light source.)
EGDC_3D_HIGH_LIGHT,
//! Light color for three-dimensional display elements (for edges facing the light source.)
EGDC_3D_LIGHT,
//! Active window border.
EGDC_ACTIVE_BORDER,
//! Active window title bar text.
EGDC_ACTIVE_CAPTION,
//! Background color of multiple document interface (MDI) applications.
EGDC_APP_WORKSPACE,
//! Text on a button
EGDC_BUTTON_TEXT,
//! Grayed (disabled) text.
EGDC_GRAY_TEXT,
//! Item(s) selected in a control.
EGDC_HIGH_LIGHT,
//! Text of item(s) selected in a control.
EGDC_HIGH_LIGHT_TEXT,
//! Inactive window border.
EGDC_INACTIVE_BORDER,
//! Inactive window caption.
EGDC_INACTIVE_CAPTION,
//! Tool tip text color
EGDC_TOOLTIP,
//! Tool tip background color
EGDC_TOOLTIP_BACKGROUND,
//! Scrollbar gray area
EGDC_SCROLLBAR,
//! Window background
EGDC_WINDOW,
//! Window symbols like on close buttons, scroll bars and check boxes
EGDC_WINDOW_SYMBOL,
//! Icons in a list or tree
EGDC_ICON,
//! Selected icons in a list or tree
EGDC_ICON_HIGH_LIGHT,
//! Grayed (disabled) window symbols like on close buttons, scroll bars and check boxes
EGDC_GRAY_WINDOW_SYMBOL,
//! Window background for editable field (editbox, checkbox-field)
EGDC_EDITABLE,
//! Grayed (disabled) window background for editable field (editbox, checkbox-field)
EGDC_GRAY_EDITABLE,
//! Show focus of window background for editable field (editbox or when checkbox-field is pressed)
EGDC_FOCUSED_EDITABLE,
//! this value is not used, it only specifies the amount of default colors
//! available.
EGDC_COUNT
};
//! Names for default skin colors
const c8 *const GUISkinColorNames[EGDC_COUNT + 1] = {
"3DDarkShadow",
"3DShadow",
"3DFace",
"3DHighlight",
"3DLight",
"ActiveBorder",
"ActiveCaption",
"AppWorkspace",
"ButtonText",
"GrayText",
"Highlight",
"HighlightText",
"InactiveBorder",
"InactiveCaption",
"ToolTip",
"ToolTipBackground",
"ScrollBar",
"Window",
"WindowSymbol",
"Icon",
"IconHighlight",
"GrayWindowSymbol",
"Editable",
"GrayEditable",
"FocusedEditable",
0,
};
//! Enumeration for default sizes.
enum EGUI_DEFAULT_SIZE
{
//! default with / height of scrollbar. Also width of drop-down button in comboboxes.
EGDS_SCROLLBAR_SIZE = 0,
//! height of menu
EGDS_MENU_HEIGHT,
//! width and height of a window titlebar button (like minimize/maximize/close buttons). The titlebar height is also calculated from that.
EGDS_WINDOW_BUTTON_WIDTH,
//! width of a checkbox check
EGDS_CHECK_BOX_WIDTH,
//! \deprecated This may be removed by Irrlicht 1.9
EGDS_MESSAGE_BOX_WIDTH,
//! \deprecated This may be removed by Irrlicht 1.9
EGDS_MESSAGE_BOX_HEIGHT,
//! width of a default button
EGDS_BUTTON_WIDTH,
//! height of a default button (OK and cancel buttons)
EGDS_BUTTON_HEIGHT,
//! distance for text from background
EGDS_TEXT_DISTANCE_X,
//! distance for text from background
EGDS_TEXT_DISTANCE_Y,
//! distance for text in the title bar, from the left of the window rect
EGDS_TITLEBARTEXT_DISTANCE_X,
//! distance for text in the title bar, from the top of the window rect
EGDS_TITLEBARTEXT_DISTANCE_Y,
//! free space in a messagebox between borders and contents on all sides
EGDS_MESSAGE_BOX_GAP_SPACE,
//! minimal space to reserve for messagebox text-width
EGDS_MESSAGE_BOX_MIN_TEXT_WIDTH,
//! maximal space to reserve for messagebox text-width
EGDS_MESSAGE_BOX_MAX_TEXT_WIDTH,
//! minimal space to reserve for messagebox text-height
EGDS_MESSAGE_BOX_MIN_TEXT_HEIGHT,
//! maximal space to reserve for messagebox text-height
EGDS_MESSAGE_BOX_MAX_TEXT_HEIGHT,
//! pixels to move an unscaled button image to the right when a button is pressed and the unpressed image looks identical
EGDS_BUTTON_PRESSED_IMAGE_OFFSET_X,
//! pixels to move an unscaled button image down when a button is pressed and the unpressed image looks identical
EGDS_BUTTON_PRESSED_IMAGE_OFFSET_Y,
//! pixels to move the button text to the right when a button is pressed
EGDS_BUTTON_PRESSED_TEXT_OFFSET_X,
//! pixels to move the button text down when a button is pressed
EGDS_BUTTON_PRESSED_TEXT_OFFSET_Y,
//! pixels to move an unscaled button sprite to the right when a button is pressed
EGDS_BUTTON_PRESSED_SPRITE_OFFSET_X,
//! pixels to move an unscaled button sprite down when a button is pressed
EGDS_BUTTON_PRESSED_SPRITE_OFFSET_Y,
//! this value is not used, it only specifies the amount of default sizes
//! available.
EGDS_COUNT
};
//! Names for default skin sizes
const c8 *const GUISkinSizeNames[EGDS_COUNT + 1] = {
"ScrollBarSize",
"MenuHeight",
"WindowButtonWidth",
"CheckBoxWidth",
"MessageBoxWidth",
"MessageBoxHeight",
"ButtonWidth",
"ButtonHeight",
"TextDistanceX",
"TextDistanceY",
"TitleBarTextX",
"TitleBarTextY",
"MessageBoxGapSpace",
"MessageBoxMinTextWidth",
"MessageBoxMaxTextWidth",
"MessageBoxMinTextHeight",
"MessageBoxMaxTextHeight",
"ButtonPressedImageOffsetX",
"ButtonPressedImageOffsetY",
"ButtonPressedTextOffsetX",
"ButtonPressedTextOffsetY",
"ButtonPressedSpriteOffsetX",
"ButtonPressedSpriteOffsetY",
0,
};
enum EGUI_DEFAULT_TEXT
{
//! Text for the OK button on a message box
EGDT_MSG_BOX_OK = 0,
//! Text for the Cancel button on a message box
EGDT_MSG_BOX_CANCEL,
//! Text for the Yes button on a message box
EGDT_MSG_BOX_YES,
//! Text for the No button on a message box
EGDT_MSG_BOX_NO,
//! Tooltip text for window close button
EGDT_WINDOW_CLOSE,
//! Tooltip text for window maximize button
EGDT_WINDOW_MAXIMIZE,
//! Tooltip text for window minimize button
EGDT_WINDOW_MINIMIZE,
//! Tooltip text for window restore button
EGDT_WINDOW_RESTORE,
//! this value is not used, it only specifies the number of default texts
EGDT_COUNT
};
//! Names for default skin sizes
const c8 *const GUISkinTextNames[EGDT_COUNT + 1] = {
"MessageBoxOkay",
"MessageBoxCancel",
"MessageBoxYes",
"MessageBoxNo",
"WindowButtonClose",
"WindowButtonMaximize",
"WindowButtonMinimize",
"WindowButtonRestore",
0,
};
//! Customizable symbols for GUI
enum EGUI_DEFAULT_ICON
{
//! maximize window button
EGDI_WINDOW_MAXIMIZE = 0,
//! restore window button
EGDI_WINDOW_RESTORE,
//! close window button
EGDI_WINDOW_CLOSE,
//! minimize window button
EGDI_WINDOW_MINIMIZE,
//! resize icon for bottom right corner of a window
EGDI_WINDOW_RESIZE,
//! scroll bar up button
EGDI_CURSOR_UP,
//! scroll bar down button
EGDI_CURSOR_DOWN,
//! scroll bar left button
EGDI_CURSOR_LEFT,
//! scroll bar right button
EGDI_CURSOR_RIGHT,
//! icon for menu children
EGDI_MENU_MORE,
//! tick for checkbox
EGDI_CHECK_BOX_CHECKED,
//! down arrow for dropdown menus
EGDI_DROP_DOWN,
//! smaller up arrow
EGDI_SMALL_CURSOR_UP,
//! smaller down arrow
EGDI_SMALL_CURSOR_DOWN,
//! selection dot in a radio button
EGDI_RADIO_BUTTON_CHECKED,
//! << icon indicating there is more content to the left
EGDI_MORE_LEFT,
//! >> icon indicating that there is more content to the right
EGDI_MORE_RIGHT,
//! icon indicating that there is more content above
EGDI_MORE_UP,
//! icon indicating that there is more content below
EGDI_MORE_DOWN,
//! plus icon for trees
EGDI_EXPAND,
//! minus icon for trees
EGDI_COLLAPSE,
//! file icon for file selection
EGDI_FILE,
//! folder icon for file selection
EGDI_DIRECTORY,
//! value not used, it only specifies the number of icons
EGDI_COUNT
};
const c8 *const GUISkinIconNames[EGDI_COUNT + 1] = {
"windowMaximize",
"windowRestore",
"windowClose",
"windowMinimize",
"windowResize",
"cursorUp",
"cursorDown",
"cursorLeft",
"cursorRight",
"menuMore",
"checkBoxChecked",
"dropDown",
"smallCursorUp",
"smallCursorDown",
"radioButtonChecked",
"moreLeft",
"moreRight",
"moreUp",
"moreDown",
"expand",
"collapse",
"file",
"directory",
0,
};
// Customizable fonts
enum EGUI_DEFAULT_FONT
{
//! For static text, edit boxes, lists and most other places
EGDF_DEFAULT = 0,
//! Font for buttons
EGDF_BUTTON,
//! Font for window title bars
EGDF_WINDOW,
//! Font for menu items
EGDF_MENU,
//! Font for tooltips
EGDF_TOOLTIP,
//! this value is not used, it only specifies the amount of default fonts
//! available.
EGDF_COUNT
};
const c8 *const GUISkinFontNames[EGDF_COUNT + 1] = {
"defaultFont",
"buttonFont",
"windowFont",
"menuFont",
"tooltipFont",
0,
};
//! A skin modifies the look of the GUI elements.
class IGUISkin : virtual public IReferenceCounted
{
public:
//! returns default color
virtual video::SColor getColor(EGUI_DEFAULT_COLOR color) const = 0;
//! sets a default color
virtual void setColor(EGUI_DEFAULT_COLOR which, video::SColor newColor) = 0;
//! returns size for the given size type
virtual s32 getSize(EGUI_DEFAULT_SIZE size) const = 0;
//! Returns a default text.
/** For example for Message box button captions:
"OK", "Cancel", "Yes", "No" and so on. */
virtual const wchar_t *getDefaultText(EGUI_DEFAULT_TEXT text) const = 0;
//! Sets a default text.
/** For example for Message box button captions:
"OK", "Cancel", "Yes", "No" and so on. */
virtual void setDefaultText(EGUI_DEFAULT_TEXT which, const wchar_t *newText) = 0;
//! sets a default size
virtual void setSize(EGUI_DEFAULT_SIZE which, s32 size) = 0;
//! returns the default font
virtual IGUIFont *getFont(EGUI_DEFAULT_FONT which = EGDF_DEFAULT) const = 0;
//! sets a default font
virtual void setFont(IGUIFont *font, EGUI_DEFAULT_FONT which = EGDF_DEFAULT) = 0;
//! returns the sprite bank
virtual IGUISpriteBank *getSpriteBank() const = 0;
//! sets the sprite bank
virtual void setSpriteBank(IGUISpriteBank *bank) = 0;
//! Returns a default icon
/** Returns the sprite index within the sprite bank */
virtual u32 getIcon(EGUI_DEFAULT_ICON icon) const = 0;
//! Sets a default icon
/** Sets the sprite index used for drawing icons like arrows,
close buttons and ticks in checkboxes
\param icon: Enum specifying which icon to change
\param index: The sprite index used to draw this icon */
virtual void setIcon(EGUI_DEFAULT_ICON icon, u32 index) = 0;
//! draws a standard 3d button pane
/** Used for drawing for example buttons in normal state.
It uses the colors EGDC_3D_DARK_SHADOW, EGDC_3D_HIGH_LIGHT, EGDC_3D_SHADOW and
EGDC_3D_FACE for this. See EGUI_DEFAULT_COLOR for details.
\param element: Pointer to the element which wishes to draw this. This parameter
is usually not used by IGUISkin, but can be used for example by more complex
implementations to find out how to draw the part exactly.
\param rect: Defining area where to draw.
\param clip: Clip area. */
virtual void draw3DButtonPaneStandard(IGUIElement *element,
const core::rect<s32> &rect,
const core::rect<s32> *clip = 0) = 0;
//! draws a pressed 3d button pane
/** Used for drawing for example buttons in pressed state.
It uses the colors EGDC_3D_DARK_SHADOW, EGDC_3D_HIGH_LIGHT, EGDC_3D_SHADOW and
EGDC_3D_FACE for this. See EGUI_DEFAULT_COLOR for details.
\param element: Pointer to the element which wishes to draw this. This parameter
is usually not used by IGUISkin, but can be used for example by more complex
implementations to find out how to draw the part exactly.
\param rect: Defining area where to draw.
\param clip: Clip area. */
virtual void draw3DButtonPanePressed(IGUIElement *element,
const core::rect<s32> &rect,
const core::rect<s32> *clip = 0) = 0;
//! draws a sunken 3d pane
/** Used for drawing the background of edit, combo or check boxes.
\param element: Pointer to the element which wishes to draw this. This parameter
is usually not used by IGUISkin, but can be used for example by more complex
implementations to find out how to draw the part exactly.
\param bgcolor: Background color.
\param flat: Specifies if the sunken pane should be flat or displayed as sunken
deep into the ground.
\param fillBackGround: Specifies if the background should be filled with the background
color or not be drawn at all.
\param rect: Defining area where to draw.
\param clip: Clip area. */
virtual void draw3DSunkenPane(IGUIElement *element,
video::SColor bgcolor, bool flat, bool fillBackGround,
const core::rect<s32> &rect,
const core::rect<s32> *clip = 0) = 0;
//! draws a window background
/** Used for drawing the background of dialogs and windows.
\param element: Pointer to the element which wishes to draw this. This parameter
is usually not used by IGUISkin, but can be used for example by more complex
implementations to find out how to draw the part exactly.
\param titleBarColor: Title color.
\param drawTitleBar: True to enable title drawing.
\param rect: Defining area where to draw.
\param clip: Clip area.
\param checkClientArea: When set to non-null the function will not draw anything,
but will instead return the clientArea which can be used for drawing by the calling window.
That is the area without borders and without titlebar.
\return Returns rect where it would be good to draw title bar text. This will
work even when checkClientArea is set to a non-null value.*/
virtual core::rect<s32> draw3DWindowBackground(IGUIElement *element,
bool drawTitleBar, video::SColor titleBarColor,
const core::rect<s32> &rect,
const core::rect<s32> *clip = 0,
core::rect<s32> *checkClientArea = 0) = 0;
//! draws a standard 3d menu pane
/** Used for drawing for menus and context menus.
It uses the colors EGDC_3D_DARK_SHADOW, EGDC_3D_HIGH_LIGHT, EGDC_3D_SHADOW and
EGDC_3D_FACE for this. See EGUI_DEFAULT_COLOR for details.
\param element: Pointer to the element which wishes to draw this. This parameter
is usually not used by IGUISkin, but can be used for example by more complex
implementations to find out how to draw the part exactly.
\param rect: Defining area where to draw.
\param clip: Clip area. */
virtual void draw3DMenuPane(IGUIElement *element,
const core::rect<s32> &rect,
const core::rect<s32> *clip = 0) = 0;
//! draws a standard 3d tool bar
/** Used for drawing for toolbars and menus.
\param element: Pointer to the element which wishes to draw this. This parameter
is usually not used by IGUISkin, but can be used for example by more complex
implementations to find out how to draw the part exactly.
\param rect: Defining area where to draw.
\param clip: Clip area. */
virtual void draw3DToolBar(IGUIElement *element,
const core::rect<s32> &rect,
const core::rect<s32> *clip = 0) = 0;
//! draws a tab button
/** Used for drawing for tab buttons on top of tabs.
\param element: Pointer to the element which wishes to draw this. This parameter
is usually not used by IGUISkin, but can be used for example by more complex
implementations to find out how to draw the part exactly.
\param active: Specifies if the tab is currently active.
\param rect: Defining area where to draw.
\param clip: Clip area.
\param alignment Alignment of GUI element. */
virtual void draw3DTabButton(IGUIElement *element, bool active,
const core::rect<s32> &rect, const core::rect<s32> *clip = 0, gui::EGUI_ALIGNMENT alignment = EGUIA_UPPERLEFT) = 0;
//! draws a tab control body
/** \param element: Pointer to the element which wishes to draw this. This parameter
is usually not used by IGUISkin, but can be used for example by more complex
implementations to find out how to draw the part exactly.
\param border: Specifies if the border should be drawn.
\param background: Specifies if the background should be drawn.
\param rect: Defining area where to draw.
\param clip: Clip area.
\param tabHeight Height of tab.
\param alignment Alignment of GUI element. */
virtual void draw3DTabBody(IGUIElement *element, bool border, bool background,
const core::rect<s32> &rect, const core::rect<s32> *clip = 0, s32 tabHeight = -1, gui::EGUI_ALIGNMENT alignment = EGUIA_UPPERLEFT) = 0;
//! draws an icon, usually from the skin's sprite bank
/** \param element: Pointer to the element which wishes to draw this icon.
This parameter is usually not used by IGUISkin, but can be used for example
by more complex implementations to find out how to draw the part exactly.
\param icon: Specifies the icon to be drawn.
\param position: The position to draw the icon
\param starttime: The time at the start of the animation
\param currenttime: The present time, used to calculate the frame number
\param loop: Whether the animation should loop or not
\param clip: Clip area. */
virtual void drawIcon(IGUIElement *element, EGUI_DEFAULT_ICON icon,
const core::position2di position, u32 starttime = 0, u32 currenttime = 0,
bool loop = false, const core::rect<s32> *clip = 0) = 0;
//! draws a 2d rectangle.
/** \param element: Pointer to the element which wishes to draw this icon.
This parameter is usually not used by IGUISkin, but can be used for example
by more complex implementations to find out how to draw the part exactly.
\param color: Color of the rectangle to draw. The alpha component specifies how
transparent the rectangle will be.
\param pos: Position of the rectangle.
\param clip: Pointer to rectangle against which the rectangle will be clipped.
If the pointer is null, no clipping will be performed. */
virtual void draw2DRectangle(IGUIElement *element, const video::SColor &color,
const core::rect<s32> &pos, const core::rect<s32> *clip = 0) = 0;
//! get the type of this skin
virtual EGUI_SKIN_TYPE getType() const { return EGST_UNKNOWN; }
};
} // end namespace gui
} // end namespace irr

138
irr/include/IGUISpriteBank.h Normal file
View File

@ -0,0 +1,138 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "irrArray.h"
#include "SColor.h"
#include "rect.h"
namespace irr
{
namespace video
{
class ITexture;
} // end namespace video
namespace gui
{
//! A single sprite frame.
// Note for implementer: Can't fix variable names to uppercase as this is a public interface used since a while
struct SGUISpriteFrame
{
SGUISpriteFrame() :
textureNumber(0), rectNumber(0)
{
}
SGUISpriteFrame(u32 textureIndex, u32 positionIndex) :
textureNumber(textureIndex), rectNumber(positionIndex)
{
}
//! Texture index in IGUISpriteBank
u32 textureNumber;
//! Index in IGUISpriteBank::getPositions()
u32 rectNumber;
};
//! A sprite composed of several frames.
// Note for implementer: Can't fix variable names to uppercase as this is a public interface used since a while
struct SGUISprite
{
SGUISprite() :
frameTime(0) {}
SGUISprite(const SGUISpriteFrame &firstFrame) :
frameTime(0)
{
Frames.push_back(firstFrame);
}
core::array<SGUISpriteFrame> Frames;
u32 frameTime;
};
//! Sprite bank interface.
/** See http://http://irrlicht.sourceforge.net/forum//viewtopic.php?f=9&t=25742
* for more information how to use the spritebank.
*/
class IGUISpriteBank : public virtual IReferenceCounted
{
public:
//! Returns the list of rectangles held by the sprite bank
virtual core::array<core::rect<s32>> &getPositions() = 0;
//! Returns the array of animated sprites within the sprite bank
virtual core::array<SGUISprite> &getSprites() = 0;
//! Returns the number of textures held by the sprite bank
virtual u32 getTextureCount() const = 0;
//! Gets the texture with the specified index
virtual video::ITexture *getTexture(u32 index) const = 0;
//! Adds a texture to the sprite bank
virtual void addTexture(video::ITexture *texture) = 0;
//! Changes one of the textures in the sprite bank
virtual void setTexture(u32 index, video::ITexture *texture) = 0;
//! Add the texture and use it for a single non-animated sprite.
/** The texture and the corresponding rectangle and sprite will all be added to the end of each array.
\returns The index of the sprite or -1 on failure */
virtual s32 addTextureAsSprite(video::ITexture *texture) = 0;
//! Clears sprites, rectangles and textures
virtual void clear() = 0;
//! Draws a sprite in 2d with position and color
/**
\param index Index of SGUISprite to draw
\param pos Target position - depending on center value either the left-top or the sprite center is used as pivot
\param clip Clipping rectangle, can be 0 when clipping is not wanted.
\param color Color with which the image is drawn.
Note that the alpha component is used. If alpha is other than
255, the image will be transparent.
\param starttime Tick when the first frame was drawn (only difference currenttime-starttime matters).
\param currenttime To calculate the frame of animated sprites
\param loop When true animations are looped
\param center When true pivot is set to the sprite-center. So it affects pos.
*/
virtual void draw2DSprite(u32 index, const core::position2di &pos,
const core::rect<s32> *clip = 0,
const video::SColor &color = video::SColor(255, 255, 255, 255),
u32 starttime = 0, u32 currenttime = 0,
bool loop = true, bool center = false) = 0;
//! Draws a sprite in 2d with destination rectangle and colors
/**
\param index Index of SGUISprite to draw
\param destRect The sprite will be scaled to fit this target rectangle
\param clip Clipping rectangle, can be 0 when clipping is not wanted.
\param colors Array of 4 colors denoting the color values of
the corners of the destRect
\param timeTicks Current frame for animated sprites
(same as currenttime-starttime in other draw2DSprite function)
\param loop When true animations are looped
*/
virtual void draw2DSprite(u32 index, const core::rect<s32> &destRect,
const core::rect<s32> *clip = 0,
const video::SColor *const colors = 0,
u32 timeTicks = 0,
bool loop = true) = 0;
//! Draws a sprite batch in 2d using an array of positions and a color
virtual void draw2DSpriteBatch(const core::array<u32> &indices, const core::array<core::position2di> &pos,
const core::rect<s32> *clip = 0,
const video::SColor &color = video::SColor(255, 255, 255, 255),
u32 starttime = 0, u32 currenttime = 0,
bool loop = true, bool center = false) = 0;
};
} // end namespace gui
} // end namespace irr

133
irr/include/IGUIStaticText.h Normal file
View File

@ -0,0 +1,133 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIElement.h"
#include "SColor.h"
namespace irr
{
namespace gui
{
class IGUIFont;
//! Multi or single line text label.
class IGUIStaticText : public IGUIElement
{
public:
//! constructor
IGUIStaticText(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_STATIC_TEXT, environment, parent, id, rectangle) {}
//! Sets another skin independent font.
/** If this is set to zero, the button uses the font of the skin.
\param font: New font to set. */
virtual void setOverrideFont(IGUIFont *font = 0) = 0;
//! Gets the override font (if any)
/** \return The override font (may be 0) */
virtual IGUIFont *getOverrideFont(void) const = 0;
//! Get the font which is used right now for drawing
/** Currently this is the override font when one is set and the
font of the active skin otherwise */
virtual IGUIFont *getActiveFont() const = 0;
//! Sets another color for the text.
/** If set, the static text does not use the EGDC_BUTTON_TEXT color defined
in the skin, but the set color instead. You don't need to call
IGUIStaticText::enableOverrrideColor(true) after this, this is done
by this function.
If you set a color, and you want the text displayed with the color
of the skin again, call IGUIStaticText::enableOverrideColor(false);
\param color: New color of the text. */
virtual void setOverrideColor(video::SColor color) = 0;
//! Gets the override color
/** \return: The override color */
virtual video::SColor getOverrideColor(void) const = 0;
//! Gets the currently used text color
/** Either a skin-color for the current state or the override color */
virtual video::SColor getActiveColor() const = 0;
//! Sets if the static text should use the override color or the color in the gui skin.
/** \param enable: If set to true, the override color, which can be set
with IGUIStaticText::setOverrideColor is used, otherwise the
EGDC_BUTTON_TEXT color of the skin. */
virtual void enableOverrideColor(bool enable) = 0;
//! Checks if an override color is enabled
/** \return true if the override color is enabled, false otherwise */
virtual bool isOverrideColorEnabled(void) const = 0;
//! Sets another color for the background.
virtual void setBackgroundColor(video::SColor color) = 0;
//! Sets whether to draw the background
virtual void setDrawBackground(bool draw) = 0;
//! Checks if background drawing is enabled
/** \return true if background drawing is enabled, false otherwise */
virtual bool isDrawBackgroundEnabled() const = 0;
//! Gets the background color
/** \return: The background color */
virtual video::SColor getBackgroundColor() const = 0;
//! Sets whether to draw the border
virtual void setDrawBorder(bool draw) = 0;
//! Checks if border drawing is enabled
/** \return true if border drawing is enabled, false otherwise */
virtual bool isDrawBorderEnabled() const = 0;
//! Sets text justification mode
/** \param horizontal: EGUIA_UPPERLEFT for left justified (default),
EGUIA_LOWERRIGHT for right justified, or EGUIA_CENTER for centered text.
\param vertical: EGUIA_UPPERLEFT to align with top edge (default),
EGUIA_LOWERRIGHT for bottom edge, or EGUIA_CENTER for centered text. */
virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical) = 0;
//! Enables or disables word wrap for using the static text as multiline text control.
/** \param enable: If set to true, words going over one line are
broken on to the next line. */
virtual void setWordWrap(bool enable) = 0;
//! Checks if word wrap is enabled
/** \return true if word wrap is enabled, false otherwise */
virtual bool isWordWrapEnabled(void) const = 0;
//! Returns the height of the text in pixels when it is drawn.
/** This is useful for adjusting the layout of gui elements based on the height
of the multiline text in this element.
\return Height of text in pixels. */
virtual s32 getTextHeight() const = 0;
//! Returns the width of the current text, in the current font
/** If the text is broken, this returns the width of the widest line
\return The width of the text, or the widest broken line. */
virtual s32 getTextWidth(void) const = 0;
//! Set whether the text in this label should be clipped if it goes outside bounds
virtual void setTextRestrainedInside(bool restrainedInside) = 0;
//! Checks if the text in this label should be clipped if it goes outside bounds
virtual bool isTextRestrainedInside() const = 0;
//! Set whether the string should be interpreted as right-to-left (RTL) text
/** \note This component does not implement the Unicode bidi standard, the
text of the component should be already RTL if you call this. The
main difference when RTL is enabled is that the linebreaks for multiline
elements are performed starting from the end.
*/
virtual void setRightToLeft(bool rtl) = 0;
//! Checks whether the text in this element should be interpreted as right-to-left
virtual bool isRightToLeft() const = 0;
};
} // end namespace gui
} // end namespace irr

149
irr/include/IGUITabControl.h Normal file
View File

@ -0,0 +1,149 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIElement.h"
#include "SColor.h"
#include "IGUISkin.h"
namespace irr
{
namespace gui
{
class IGUITab;
//! A standard tab control
/** \par This element can create the following events of type EGUI_EVENT_TYPE:
\li EGET_TAB_CHANGED
*/
class IGUITabControl : public IGUIElement
{
public:
//! constructor
IGUITabControl(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_TAB_CONTROL, environment, parent, id, rectangle) {}
//! Adds a tab
virtual IGUITab *addTab(const wchar_t *caption, s32 id = -1) = 0;
//! Adds an existing tab
/** Note that it will also add the tab as a child of this TabControl.
\return Index of added tab or -1 for failure*/
virtual s32 addTab(IGUITab *tab) = 0;
//! Insert the tab at the given index
/** \return The tab on success or NULL on failure. */
virtual IGUITab *insertTab(s32 idx, const wchar_t *caption, s32 id = -1) = 0;
//! Insert an existing tab
/** Note that it will also add the tab as a child of this TabControl.
\param idx Index at which tab will be inserted. Later tabs will be moved.
Previous active tab will stay active unless this is the first
element to be inserted in which case it becomes active.
\param tab New tab to insert.
\param serializationMode Internally used for serialization. You should not need this.
When true it reserves space for the index, doesn't move but replaces tabs
and it doesn't change the active tab.
\return Index of added tab (should be same as the one passed) or -1 for failure*/
virtual s32 insertTab(s32 idx, IGUITab *tab, bool serializationMode = false) = 0;
//! Removes a tab from the tabcontrol
virtual void removeTab(s32 idx) = 0;
//! Clears the tabcontrol removing all tabs
virtual void clear() = 0;
//! Returns amount of tabs in the tabcontrol
virtual s32 getTabCount() const = 0;
//! Returns a tab based on zero based index
/** \param idx: zero based index of tab. Is a value between 0 and getTabcount()-1;
\return Returns pointer to the Tab. Returns 0 if no tab
is corresponding to this tab. */
virtual IGUITab *getTab(s32 idx) const = 0;
//! For given element find if it's a tab and return it's zero-based index (or -1 for not found)
/** \param tab Tab for which we are looking (usually you will look for an IGUITab* type as only
those can be tabs, but we allow looking for any kind of IGUIElement* as there are some
use-cases for that even if it just returns 0. For example this way you can check for
all children of this gui-element if they are tabs or some non-tab children.*/
virtual s32 getTabIndex(const IGUIElement *tab) const = 0;
//! Brings a tab to front.
/** \param idx: number of the tab.
\return Returns true if successful. */
virtual bool setActiveTab(s32 idx) = 0;
//! Brings a tab to front.
/** \param tab: pointer to the tab.
\return Returns true if successful. */
virtual bool setActiveTab(IGUITab *tab) = 0;
//! Returns which tab is currently active
virtual s32 getActiveTab() const = 0;
//! get the the id of the tab at the given absolute coordinates
/** \return The id of the tab or -1 when no tab is at those coordinates*/
virtual s32 getTabAt(s32 xpos, s32 ypos) const = 0;
//! Set the height of the tabs
virtual void setTabHeight(s32 height) = 0;
//! Get the height of the tabs
/** return Returns the height of the tabs */
virtual s32 getTabHeight() const = 0;
//! set the maximal width of a tab. Per default width is 0 which means "no width restriction".
virtual void setTabMaxWidth(s32 width) = 0;
//! get the maximal width of a tab
virtual s32 getTabMaxWidth() const = 0;
//! Set the alignment of the tabs
/** Use EGUIA_UPPERLEFT or EGUIA_LOWERRIGHT */
virtual void setTabVerticalAlignment(gui::EGUI_ALIGNMENT alignment) = 0;
//! Get the alignment of the tabs
/** return Returns the alignment of the tabs */
virtual gui::EGUI_ALIGNMENT getTabVerticalAlignment() const = 0;
//! Set the extra width added to tabs on each side of the text
virtual void setTabExtraWidth(s32 extraWidth) = 0;
//! Get the extra width added to tabs on each side of the text
/** return Returns the extra width of the tabs */
virtual s32 getTabExtraWidth() const = 0;
};
//! A tab-page, onto which other gui elements could be added.
/** IGUITab refers mostly to the page itself, but also carries some data about the tab in the tabbar of an IGUITabControl. */
class IGUITab : public IGUIElement
{
public:
//! constructor
IGUITab(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_TAB, environment, parent, id, rectangle) {}
//! sets if the tab should draw its background
virtual void setDrawBackground(bool draw = true) = 0;
//! sets the color of the background, if it should be drawn.
virtual void setBackgroundColor(video::SColor c) = 0;
//! returns true if the tab is drawing its background, false if not
virtual bool isDrawingBackground() const = 0;
//! returns the color of the background
virtual video::SColor getBackgroundColor() const = 0;
//! sets the color of it's text in the tab-bar
virtual void setTextColor(video::SColor c) = 0;
//! gets the color of the text
virtual video::SColor getTextColor() const = 0;
};
} // end namespace gui
} // end namespace irr

34
irr/include/IGUIToolbar.h Normal file
View File

@ -0,0 +1,34 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IGUIElement.h"
namespace irr
{
namespace video
{
class ITexture;
} // end namespace video
namespace gui
{
class IGUIButton;
//! Stays at the top of its parent like the menu bar and contains tool buttons
class IGUIToolBar : public IGUIElement
{
public:
//! constructor
IGUIToolBar(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_TOOL_BAR, environment, parent, id, rectangle) {}
//! Adds a button to the tool bar
virtual IGUIButton *addButton(s32 id = -1, const wchar_t *text = 0, const wchar_t *tooltiptext = 0,
video::ITexture *img = 0, video::ITexture *pressedimg = 0,
bool isPushButton = false, bool useAlphaChannel = false) = 0;
};
} // end namespace gui
} // end namespace irr

424
irr/include/IImage.h Normal file
View File

@ -0,0 +1,424 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "position2d.h"
#include "rect.h"
#include "SColor.h"
#include <cstring>
namespace irr
{
namespace video
{
//! Interface for software image data.
/** Image loaders create these images from files. IVideoDrivers convert
these images into their (hardware) textures.
NOTE: Floating point formats are not well supported yet. Basically only getData() works for them.
*/
class IImage : public virtual IReferenceCounted
{
public:
//! constructor
IImage(ECOLOR_FORMAT format, const core::dimension2d<u32> &size, bool deleteMemory) :
Format(format), Size(size), Data(0), MipMapsData(0), BytesPerPixel(0), Pitch(0), DeleteMemory(deleteMemory), DeleteMipMapsMemory(false)
{
BytesPerPixel = getBitsPerPixelFromFormat(Format) / 8;
Pitch = BytesPerPixel * Size.Width;
}
//! destructor
virtual ~IImage()
{
if (DeleteMemory)
delete[] Data;
if (DeleteMipMapsMemory)
delete[] MipMapsData;
}
//! Returns the color format
ECOLOR_FORMAT getColorFormat() const
{
return Format;
}
//! Returns width and height of image data.
const core::dimension2d<u32> &getDimension() const
{
return Size;
}
//! Returns bits per pixel.
u32 getBitsPerPixel() const
{
return getBitsPerPixelFromFormat(Format);
}
//! Returns bytes per pixel
u32 getBytesPerPixel() const
{
return BytesPerPixel;
}
//! Returns image data size in bytes
u32 getImageDataSizeInBytes() const
{
return getDataSizeFromFormat(Format, Size.Width, Size.Height);
}
//! Returns image data size in pixels
u32 getImageDataSizeInPixels() const
{
return Size.Width * Size.Height;
}
//! Returns pitch of image
u32 getPitch() const
{
return Pitch;
}
//! Returns mask for red value of a pixel
u32 getRedMask() const
{
switch (Format) {
case ECF_A1R5G5B5:
return 0x1F << 10;
case ECF_R5G6B5:
return 0x1F << 11;
case ECF_R8G8B8:
return 0x00FF0000;
case ECF_A8R8G8B8:
return 0x00FF0000;
default:
return 0x0;
}
}
//! Returns mask for green value of a pixel
u32 getGreenMask() const
{
switch (Format) {
case ECF_A1R5G5B5:
return 0x1F << 5;
case ECF_R5G6B5:
return 0x3F << 5;
case ECF_R8G8B8:
return 0x0000FF00;
case ECF_A8R8G8B8:
return 0x0000FF00;
default:
return 0x0;
}
}
//! Returns mask for blue value of a pixel
u32 getBlueMask() const
{
switch (Format) {
case ECF_A1R5G5B5:
return 0x1F;
case ECF_R5G6B5:
return 0x1F;
case ECF_R8G8B8:
return 0x000000FF;
case ECF_A8R8G8B8:
return 0x000000FF;
default:
return 0x0;
}
}
//! Returns mask for alpha value of a pixel
u32 getAlphaMask() const
{
switch (Format) {
case ECF_A1R5G5B5:
return 0x1 << 15;
case ECF_R5G6B5:
return 0x0;
case ECF_R8G8B8:
return 0x0;
case ECF_A8R8G8B8:
return 0xFF000000;
default:
return 0x0;
}
}
//! Use this to get a pointer to the image data.
/**
\return Pointer to the image data. What type of data is pointed to
depends on the color format of the image. For example if the color
format is ECF_A8R8G8B8, it is of u32. */
void *getData() const
{
return Data;
}
//! Get the mipmap size for this image for a certain mipmap level
/** level 0 will be full image size. Every further level is half the size.
Doesn't care if the image actually has mipmaps, just which size would be needed. */
core::dimension2du getMipMapsSize(u32 mipmapLevel) const
{
return getMipMapsSize(Size, mipmapLevel);
}
//! Calculate mipmap size for a certain level
/** level 0 will be full image size. Every further level is half the size. */
static core::dimension2du getMipMapsSize(const core::dimension2du &sizeLevel0, u32 mipmapLevel)
{
core::dimension2du result(sizeLevel0);
u32 i = 0;
while (i != mipmapLevel) {
if (result.Width > 1)
result.Width >>= 1;
if (result.Height > 1)
result.Height >>= 1;
++i;
if (result.Width == 1 && result.Height == 1 && i < mipmapLevel)
return core::dimension2du(0, 0);
}
return result;
}
//! Get mipmaps data.
/** Note that different mip levels are just behind each other in memory block.
So if you just get level 1 you also have the data for all other levels.
There is no level 0 - use getData to get the original image data.
*/
void *getMipMapsData(irr::u32 mipLevel = 1) const
{
if (MipMapsData && mipLevel > 0) {
size_t dataSize = 0;
core::dimension2du mipSize(Size);
u32 i = 1; // We want the start of data for this level, not end.
while (i != mipLevel) {
if (mipSize.Width > 1)
mipSize.Width >>= 1;
if (mipSize.Height > 1)
mipSize.Height >>= 1;
dataSize += getDataSizeFromFormat(Format, mipSize.Width, mipSize.Height);
++i;
if (mipSize.Width == 1 && mipSize.Height == 1 && i < mipLevel)
return 0;
}
return MipMapsData + dataSize;
}
return 0;
}
//! Set mipmaps data.
/** This method allows you to put custom mipmaps data for
image.
\param data A byte array with pixel color information
\param ownForeignMemory If true, the image will use the data
pointer directly and own it afterward. If false, the memory
will by copied internally.
\param deleteMemory Whether the memory is deallocated upon
destruction. */
void setMipMapsData(void *data, bool ownForeignMemory)
{
if (data != MipMapsData) {
if (DeleteMipMapsMemory) {
delete[] MipMapsData;
DeleteMipMapsMemory = false;
}
if (data) {
if (ownForeignMemory) {
MipMapsData = static_cast<u8 *>(data);
DeleteMipMapsMemory = false;
} else {
u32 dataSize = 0;
u32 width = Size.Width;
u32 height = Size.Height;
do {
if (width > 1)
width >>= 1;
if (height > 1)
height >>= 1;
dataSize += getDataSizeFromFormat(Format, width, height);
} while (width != 1 || height != 1);
MipMapsData = new u8[dataSize];
memcpy(MipMapsData, data, dataSize);
DeleteMipMapsMemory = true;
}
} else {
MipMapsData = 0;
}
}
}
//! Returns a pixel
virtual SColor getPixel(u32 x, u32 y) const = 0;
//! Sets a pixel
virtual void setPixel(u32 x, u32 y, const SColor &color, bool blend = false) = 0;
//! Copies this surface into another, if it has the exact same size and format.
/** NOTE: mipmaps are ignored
\return True if it was copied, false otherwise.
*/
virtual bool copyToNoScaling(void *target, u32 width, u32 height, ECOLOR_FORMAT format = ECF_A8R8G8B8, u32 pitch = 0) const = 0;
//! Copies the image into the target, scaling the image to fit
/** NOTE: mipmaps are ignored */
virtual void copyToScaling(void *target, u32 width, u32 height, ECOLOR_FORMAT format = ECF_A8R8G8B8, u32 pitch = 0) = 0;
//! Copies the image into the target, scaling the image to fit
/** NOTE: mipmaps are ignored */
virtual void copyToScaling(IImage *target) = 0;
//! copies this surface into another
/** NOTE: mipmaps are ignored */
virtual void copyTo(IImage *target, const core::position2d<s32> &pos = core::position2d<s32>(0, 0)) = 0;
//! copies this surface into another
/** NOTE: mipmaps are ignored */
virtual void copyTo(IImage *target, const core::position2d<s32> &pos, const core::rect<s32> &sourceRect, const core::rect<s32> *clipRect = 0) = 0;
//! copies this surface into another, using the alpha mask and cliprect and a color to add with
/** NOTE: mipmaps are ignored
\param combineAlpha - When true then combine alpha channels. When false replace target image alpha with source image alpha.
*/
virtual void copyToWithAlpha(IImage *target, const core::position2d<s32> &pos,
const core::rect<s32> &sourceRect, const SColor &color,
const core::rect<s32> *clipRect = 0,
bool combineAlpha = false) = 0;
//! copies this surface into another, scaling it to fit, applying a box filter
/** NOTE: mipmaps are ignored */
virtual void copyToScalingBoxFilter(IImage *target, s32 bias = 0, bool blend = false) = 0;
//! fills the surface with given color
virtual void fill(const SColor &color) = 0;
//! get the amount of Bits per Pixel of the given color format
static u32 getBitsPerPixelFromFormat(const ECOLOR_FORMAT format)
{
switch (format) {
case ECF_A1R5G5B5:
return 16;
case ECF_R5G6B5:
return 16;
case ECF_R8G8B8:
return 24;
case ECF_A8R8G8B8:
return 32;
case ECF_D16:
return 16;
case ECF_D32:
return 32;
case ECF_D24S8:
return 32;
case ECF_R8:
return 8;
case ECF_R8G8:
return 16;
case ECF_R16:
return 16;
case ECF_R16G16:
return 32;
case ECF_R16F:
return 16;
case ECF_G16R16F:
return 32;
case ECF_A16B16G16R16F:
return 64;
case ECF_R32F:
return 32;
case ECF_G32R32F:
return 64;
case ECF_A32B32G32R32F:
return 128;
default:
return 0;
}
}
//! calculate image data size in bytes for selected format, width and height.
static u32 getDataSizeFromFormat(ECOLOR_FORMAT format, u32 width, u32 height)
{
// non-compressed formats
u32 imageSize = getBitsPerPixelFromFormat(format) / 8 * width;
imageSize *= height;
return imageSize;
}
//! check if this is compressed color format
static bool isCompressedFormat(const ECOLOR_FORMAT format)
{
return false;
}
//! check if the color format is only viable for depth/stencil textures
static bool isDepthFormat(const ECOLOR_FORMAT format)
{
switch (format) {
case ECF_D16:
case ECF_D32:
case ECF_D24S8:
return true;
default:
return false;
}
}
//! Check if the color format uses floating point values for pixels
static bool isFloatingPointFormat(const ECOLOR_FORMAT format)
{
if (isCompressedFormat(format))
return false;
switch (format) {
case ECF_R16F:
case ECF_G16R16F:
case ECF_A16B16G16R16F:
case ECF_R32F:
case ECF_G32R32F:
case ECF_A32B32G32R32F:
return true;
default:
break;
}
return false;
}
protected:
ECOLOR_FORMAT Format;
core::dimension2d<u32> Size;
u8 *Data;
u8 *MipMapsData;
u32 BytesPerPixel;
u32 Pitch;
bool DeleteMemory;
bool DeleteMipMapsMemory;
};
} // end namespace video
} // end namespace irr

49
irr/include/IImageLoader.h Normal file
View File

@ -0,0 +1,49 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "IImage.h"
#include "ITexture.h"
#include "path.h"
#include "irrArray.h"
namespace irr
{
namespace io
{
class IReadFile;
} // end namespace io
namespace video
{
//! Class which is able to create a image from a file.
/** If you want the Irrlicht Engine be able to load textures of
currently unsupported file formats (e.g .gif), then implement
this and add your new Surface loader with
IVideoDriver::addExternalImageLoader() to the engine. */
class IImageLoader : public virtual IReferenceCounted
{
public:
//! Check if the file might be loaded by this class
/** Check is based on the file extension (e.g. ".tga")
\param filename Name of file to check.
\return True if file seems to be loadable. */
virtual bool isALoadableFileExtension(const io::path &filename) const = 0;
//! Check if the file might be loaded by this class
/** Check might look into the file.
\param file File handle to check.
\return True if file seems to be loadable. */
virtual bool isALoadableFileFormat(io::IReadFile *file) const = 0;
//! Creates a surface from the file
/** \param file File handle to check.
\return Pointer to newly created image, or 0 upon error. */
virtual IImage *loadImage(io::IReadFile *file) const = 0;
};
} // end namespace video
} // end namespace irr

40
irr/include/IImageWriter.h Normal file
View File

@ -0,0 +1,40 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "irrString.h"
#include "coreutil.h"
namespace irr
{
namespace io
{
class IWriteFile;
} // end namespace io
namespace video
{
class IImage;
//! Interface for writing software image data.
class IImageWriter : public IReferenceCounted
{
public:
//! Check if this writer can write a file with the given extension
/** \param filename Name of the file to check.
\return True if file extension specifies a writable type. */
virtual bool isAWriteableFileExtension(const io::path &filename) const = 0;
//! Write image to file
/** \param file File handle to write to.
\param image Image to write into file.
\param param Writer specific parameter, influencing e.g. quality.
\return True if image was successfully written. */
virtual bool writeImage(io::IWriteFile *file, IImage *image, u32 param = 0) const = 0;
};
} // namespace video
} // namespace irr

59
irr/include/IIndexBuffer.h Normal file
View File

@ -0,0 +1,59 @@
// Copyright (C) 2008-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "irrArray.h"
#include "EHardwareBufferFlags.h"
#include "SVertexIndex.h"
namespace irr
{
namespace video
{
}
namespace scene
{
class IIndexBuffer : public virtual IReferenceCounted
{
public:
virtual void *getData() = 0;
virtual video::E_INDEX_TYPE getType() const = 0;
virtual void setType(video::E_INDEX_TYPE IndexType) = 0;
virtual u32 stride() const = 0;
virtual u32 size() const = 0;
virtual void push_back(const u32 &element) = 0;
virtual u32 operator[](u32 index) const = 0;
virtual u32 getLast() = 0;
virtual void setValue(u32 index, u32 value) = 0;
virtual void set_used(u32 usedNow) = 0;
virtual void reallocate(u32 new_size) = 0;
virtual u32 allocated_size() const = 0;
virtual void *pointer() = 0;
//! get the current hardware mapping hint
virtual E_HARDWARE_MAPPING getHardwareMappingHint() const = 0;
//! set the hardware mapping hint, for driver
virtual void setHardwareMappingHint(E_HARDWARE_MAPPING NewMappingHint) = 0;
//! flags the meshbuffer as changed, reloads hardware buffers
virtual void setDirty() = 0;
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
virtual u32 getChangedID() const = 0;
};
} // end namespace scene
} // end namespace irr

75
irr/include/ILogger.h Normal file
View File

@ -0,0 +1,75 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
namespace irr
{
//! Possible log levels.
//! When used has filter ELL_DEBUG means => log everything and ELL_NONE means => log (nearly) nothing.
//! When used to print logging information ELL_DEBUG will have lowest priority while ELL_NONE
//! messages are never filtered and always printed.
enum ELOG_LEVEL
{
//! Used for printing information helpful in debugging
ELL_DEBUG,
//! Useful information to print. For example hardware info or something started/stopped.
ELL_INFORMATION,
//! Warnings that something isn't as expected and can cause oddities
ELL_WARNING,
//! Something did go wrong.
ELL_ERROR,
//! Logs with ELL_NONE will never be filtered.
//! And used as filter it will remove all logging except ELL_NONE messages.
ELL_NONE
};
//! Interface for logging messages, warnings and errors
class ILogger : public virtual IReferenceCounted
{
public:
//! Destructor
virtual ~ILogger() {}
//! Returns the current set log level.
virtual ELOG_LEVEL getLogLevel() const = 0;
//! Sets a new log level.
/** With this value, texts which are sent to the logger are filtered
out. For example setting this value to ELL_WARNING, only warnings and
errors are printed out. Setting it to ELL_INFORMATION, which is the
default setting, warnings, errors and informational texts are printed
out.
\param ll: new log level filter value. */
virtual void setLogLevel(ELOG_LEVEL ll) = 0;
//! Prints out a text into the log
/** \param text: Text to print out.
\param ll: Log level of the text. If the text is an error, set
it to ELL_ERROR, if it is warning set it to ELL_WARNING, and if it
is just an informational text, set it to ELL_INFORMATION. Texts are
filtered with these levels. If you want to be a text displayed,
independent on what level filter is set, use ELL_NONE. */
virtual void log(const c8 *text, ELOG_LEVEL ll = ELL_INFORMATION) = 0;
//! Prints out a text into the log
/** \param text: Text to print out.
\param hint: Additional info. This string is added after a " :" to the
string.
\param ll: Log level of the text. If the text is an error, set
it to ELL_ERROR, if it is warning set it to ELL_WARNING, and if it
is just an informational text, set it to ELL_INFORMATION. Texts are
filtered with these levels. If you want to be a text displayed,
independent on what level filter is set, use ELL_NONE. */
virtual void log(const c8 *text, const c8 *hint, ELOG_LEVEL ll = ELL_INFORMATION) = 0;
};
} // end namespace

101
irr/include/IMaterialRenderer.h Normal file
View File

@ -0,0 +1,101 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "SMaterial.h"
#include "S3DVertex.h"
namespace irr
{
namespace video
{
class IVideoDriver;
class IMaterialRendererServices;
class IShaderConstantSetCallBack;
//! Interface for material rendering.
/** Can be used to extend the engine with new materials. Refer to
IVideoDriver::addMaterialRenderer() for more information on how to extend the
engine with new materials. */
class IMaterialRenderer : public virtual IReferenceCounted
{
public:
//! Called by the IVideoDriver implementation the let the renderer set its needed render states.
/** This is called during the IVideoDriver::setMaterial() call.
When overriding this, you can set some renderstates or for example a
vertex or pixel shader if you like.
\param material: The new material parameters to be set. The renderer
may change the material flags in this material. For example if this
material does not accept the zbuffer = true, it can set it to false.
This is useful, because in the next lastMaterial will be just the
material in this call.
\param lastMaterial: The material parameters which have been set before
this material.
\param resetAllRenderstates: True if all renderstates should really be
reset. This is usually true if the last rendering mode was not a usual
3d rendering mode, but for example a 2d rendering mode.
You should reset really all renderstates if this is true, no matter if
the lastMaterial had some similar settings. This is used because in
most cases, some common renderstates are not changed if they are
already there, for example bilinear filtering, wireframe,
gouraudshading, lighting, zbuffer, zwriteenable, backfaceculling and
fogenable.
\param services: Interface providing some methods for changing
advanced, internal states of a IVideoDriver. */
virtual void OnSetMaterial(const SMaterial &material, const SMaterial &lastMaterial,
bool resetAllRenderstates, IMaterialRendererServices *services) {}
//! Called every time before a new bunch of geometry is being drawn using this material with for example drawIndexedTriangleList() call.
/** OnSetMaterial should normally only be called if the renderer decides
that the renderstates should be changed, it won't be called if for
example two drawIndexedTriangleList() will be called with the same
material set. This method will be called every time. This is useful for
example for materials with shaders, which don't only set new
renderstates but also shader constants.
\param service: Pointer to interface providing methods for setting
constants and other things.
\param vtxtype: Vertex type with which the next rendering will be done.
This can be used by the material renderer to set some specific
optimized shaders or if this is an incompatible vertex type for this
renderer, to refuse rendering for example.
\return Returns true if everything is OK, and false if nothing should
be rendered. The material renderer can choose to return false for
example if he doesn't support the specified vertex type. This is
actually done in D3D9 when using a normal mapped material with
a vertex type other than EVT_TANGENTS. */
virtual bool OnRender(IMaterialRendererServices *service, E_VERTEX_TYPE vtxtype) { return true; }
//! Called by the IVideoDriver to unset this material.
/** Called during the IVideoDriver::setMaterial() call before the new
material will get the OnSetMaterial() call. */
virtual void OnUnsetMaterial() {}
//! Returns if the material is transparent.
/** The scene management needs to know this
for being able to sort the materials by opaque and transparent. */
virtual bool isTransparent() const { return false; }
//! Returns the render capability of the material.
/** Because some more complex materials
are implemented in multiple ways and need special hardware capabilities, it is possible
to query how the current material renderer is performing on the current hardware with this
function.
\return Returns 0 if everything is running fine. Any other value is material renderer
specific and means for example that the renderer switched back to a fall back material because
it cannot use the latest shaders. More specific examples:
Fixed function pipeline materials should return 0 in most cases, parallax mapped
material will only return 0 when at least pixel shader 1.4 is available on that machine. */
virtual s32 getRenderCapability() const { return 0; }
//! Access the callback provided by the users when creating shader materials
/** \returns Returns either the users provided callback or 0 when no such
callback exists. Non-shader materials will always return 0. */
virtual IShaderConstantSetCallBack *getShaderConstantSetCallBack() const { return 0; }
};
} // end namespace video
} // end namespace irr

80
irr/include/IMaterialRendererServices.h Normal file
View File

@ -0,0 +1,80 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "SMaterial.h"
#include "S3DVertex.h"
namespace irr
{
namespace video
{
class IVideoDriver;
//! Interface providing some methods for changing advanced, internal states of a IVideoDriver.
class IMaterialRendererServices
{
public:
//! Destructor
virtual ~IMaterialRendererServices() {}
//! Can be called by an IMaterialRenderer to make its work easier.
/** Sets all basic renderstates if needed.
Basic render states are diffuse, ambient, specular, and emissive color,
specular power, bilinear and trilinear filtering, wireframe mode,
grouraudshading, lighting, zbuffer, zwriteenable, backfaceculling and
fog enabling.
\param material The new material to be used.
\param lastMaterial The material used until now.
\param resetAllRenderstates Set to true if all renderstates should be
set, regardless of their current state. */
virtual void setBasicRenderStates(const SMaterial &material,
const SMaterial &lastMaterial,
bool resetAllRenderstates) = 0;
//! Return an index constant for the vertex shader based on a uniform variable name.
virtual s32 getVertexShaderConstantID(const c8 *name) = 0;
//! Sets a value for a vertex shader uniform variable.
/** \param index Index of the variable (as received from getVertexShaderConstantID)
\param floats Pointer to array of floats
\param count Amount of floats in array.
\return True if successful.
*/
virtual bool setVertexShaderConstant(s32 index, const f32 *floats, int count) = 0;
//! Int interface for the above.
virtual bool setVertexShaderConstant(s32 index, const s32 *ints, int count) = 0;
//! Uint interface for the above.
virtual bool setVertexShaderConstant(s32 index, const u32 *ints, int count) = 0;
//! Return an index constant for the pixel shader for the given uniform variable name
virtual s32 getPixelShaderConstantID(const c8 *name) = 0;
//! Sets a value for the given pixel shader uniform variable
/** This can be used if you used a high level shader language like GLSL
or HLSL to create a shader. See setVertexShaderConstant() for an
example on how to use this.
\param index Index of the variable (as received from getPixelShaderConstantID)
\param floats Pointer to array of floats
\param count Amount of floats in array.
\return True if successful. */
virtual bool setPixelShaderConstant(s32 index, const f32 *floats, int count) = 0;
//! Int interface for the above.
virtual bool setPixelShaderConstant(s32 index, const s32 *ints, int count) = 0;
//! Uint interface for the above.
virtual bool setPixelShaderConstant(s32 index, const u32 *ints, int count) = 0;
//! Get pointer to the IVideoDriver interface
/** \return Pointer to the IVideoDriver interface */
virtual IVideoDriver *getVideoDriver() = 0;
};
} // end namespace video
} // end namespace irr

27
irr/include/IMemoryReadFile.h Normal file
View File

@ -0,0 +1,27 @@
// Copyright Michael Zeilfelder
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReadFile.h"
namespace irr
{
namespace io
{
//! Interface providing read access to a memory read file.
class IMemoryReadFile : public IReadFile
{
public:
//! Get direct access to internal buffer of memory block used as file.
/** It's usually better to use the IReadFile functions to access
the file content. But as that buffer exist over the full life-time
of a CMemoryReadFile, it's sometimes nice to avoid the additional
data-copy which read() needs.
*/
virtual const void *getBuffer() const = 0;
};
} // end namespace io
} // end namespace irr

123
irr/include/IMesh.h Normal file
View File

@ -0,0 +1,123 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "SMaterial.h"
#include "EHardwareBufferFlags.h"
namespace irr
{
namespace scene
{
//! Possible types of meshes.
// Note: Was previously only used in IAnimatedMesh so it still has the "animated" in the name.
// But can now be used for all mesh-types as we need those casts as well.
enum E_ANIMATED_MESH_TYPE
{
//! Unknown animated mesh type.
EAMT_UNKNOWN = 0,
//! Quake 2 MD2 model file
EAMT_MD2,
//! Quake 3 MD3 model file
EAMT_MD3,
//! Maya .obj static model
EAMT_OBJ,
//! Quake 3 .bsp static Map
EAMT_BSP,
//! 3D Studio .3ds file
EAMT_3DS,
//! My3D Mesh, the file format by Zhuck Dimitry
EAMT_MY3D,
//! Pulsar LMTools .lmts file. This Irrlicht loader was written by Jonas Petersen
EAMT_LMTS,
//! Cartography Shop .csm file. This loader was created by Saurav Mohapatra.
EAMT_CSM,
//! .oct file for Paul Nette's FSRad or from Murphy McCauley's Blender .oct exporter.
/** The oct file format contains 3D geometry and lightmaps and
can be loaded directly by Irrlicht */
EAMT_OCT,
//! Halflife MDL model file
EAMT_MDL_HALFLIFE,
//! generic skinned mesh
EAMT_SKINNED,
//! generic non-animated mesh
EAMT_STATIC
};
class IMeshBuffer;
//! Class which holds the geometry of an object.
/** An IMesh is nothing more than a collection of some mesh buffers
(IMeshBuffer). SMesh is a simple implementation of an IMesh.
A mesh is usually added to an IMeshSceneNode in order to be rendered.
*/
class IMesh : public virtual IReferenceCounted
{
public:
//! Get the amount of mesh buffers.
/** \return Amount of mesh buffers (IMeshBuffer) in this mesh. */
virtual u32 getMeshBufferCount() const = 0;
//! Get pointer to a mesh buffer.
/** \param nr: Zero based index of the mesh buffer. The maximum value is
getMeshBufferCount() - 1;
\return Pointer to the mesh buffer or 0 if there is no such
mesh buffer. */
virtual IMeshBuffer *getMeshBuffer(u32 nr) const = 0;
//! Get pointer to a mesh buffer which fits a material
/** \param material: material to search for
\return Pointer to the mesh buffer or 0 if there is no such
mesh buffer. */
virtual IMeshBuffer *getMeshBuffer(const video::SMaterial &material) const = 0;
//! Get an axis aligned bounding box of the mesh.
/** \return Bounding box of this mesh. */
virtual const core::aabbox3d<f32> &getBoundingBox() const = 0;
//! Set user-defined axis aligned bounding box
/** \param box New bounding box to use for the mesh. */
virtual void setBoundingBox(const core::aabbox3df &box) = 0;
//! Set the hardware mapping hint
/** This methods allows to define optimization hints for the
hardware. This enables, e.g., the use of hardware buffers on
platforms that support this feature. This can lead to noticeable
performance gains. */
virtual void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer = EBT_VERTEX_AND_INDEX) = 0;
//! Flag the meshbuffer as changed, reloads hardware buffers
/** This method has to be called every time the vertices or
indices have changed. Otherwise, changes won't be updated
on the GPU in the next render cycle. */
virtual void setDirty(E_BUFFER_TYPE buffer = EBT_VERTEX_AND_INDEX) = 0;
//! Returns the type of the meshes.
/** This is useful for making a safe downcast. For example,
if getMeshType() returns EAMT_MD2 it's safe to cast the
IMesh to IAnimatedMeshMD2.
Note: It's no longer just about animated meshes, that name has just historical reasons.
\returns Type of the mesh */
virtual E_ANIMATED_MESH_TYPE getMeshType() const
{
return EAMT_STATIC;
}
};
} // end namespace scene
} // end namespace irr

182
irr/include/IMeshBuffer.h Normal file
View File

@ -0,0 +1,182 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "SMaterial.h"
#include "aabbox3d.h"
#include "S3DVertex.h"
#include "SVertexIndex.h"
#include "EHardwareBufferFlags.h"
#include "EPrimitiveTypes.h"
namespace irr
{
namespace scene
{
//! Struct for holding a mesh with a single material.
/** A part of an IMesh which has the same material on each face of that
group. Logical groups of an IMesh need not be put into separate mesh
buffers, but can be. Separately animated parts of the mesh must be put
into separate mesh buffers.
Some mesh buffer implementations have limitations on the number of
vertices the buffer can hold. In that case, logical grouping can help.
Moreover, the number of vertices should be optimized for the GPU upload,
which often depends on the type of gfx card. Typical figures are
1000-10000 vertices per buffer.
SMeshBuffer is a simple implementation of a MeshBuffer, which supports
up to 65535 vertices.
Since meshbuffers are used for drawing, and hence will be exposed
to the driver, chances are high that they are grab()'ed from somewhere.
It's therefore required to dynamically allocate meshbuffers which are
passed to a video driver and only drop the buffer once it's not used in
the current code block anymore.
*/
class IMeshBuffer : public virtual IReferenceCounted
{
public:
//! Get the material of this meshbuffer
/** \return Material of this buffer. */
virtual video::SMaterial &getMaterial() = 0;
//! Get the material of this meshbuffer
/** \return Material of this buffer. */
virtual const video::SMaterial &getMaterial() const = 0;
//! Get type of vertex data which is stored in this meshbuffer.
/** \return Vertex type of this buffer. */
virtual video::E_VERTEX_TYPE getVertexType() const = 0;
//! Get access to vertex data. The data is an array of vertices.
/** Which vertex type is used can be determined by getVertexType().
\return Pointer to array of vertices. */
virtual const void *getVertices() const = 0;
//! Get access to vertex data. The data is an array of vertices.
/** Which vertex type is used can be determined by getVertexType().
\return Pointer to array of vertices. */
virtual void *getVertices() = 0;
//! Get amount of vertices in meshbuffer.
/** \return Number of vertices in this buffer. */
virtual u32 getVertexCount() const = 0;
//! Get type of index data which is stored in this meshbuffer.
/** \return Index type of this buffer. */
virtual video::E_INDEX_TYPE getIndexType() const = 0;
//! Get access to indices.
/** \return Pointer to indices array. */
virtual const u16 *getIndices() const = 0;
//! Get access to indices.
/** \return Pointer to indices array. */
virtual u16 *getIndices() = 0;
//! Get amount of indices in this meshbuffer.
/** \return Number of indices in this buffer. */
virtual u32 getIndexCount() const = 0;
//! Get the axis aligned bounding box of this meshbuffer.
/** \return Axis aligned bounding box of this buffer. */
virtual const core::aabbox3df &getBoundingBox() const = 0;
//! Set axis aligned bounding box
/** \param box User defined axis aligned bounding box to use
for this buffer. */
virtual void setBoundingBox(const core::aabbox3df &box) = 0;
//! Recalculates the bounding box. Should be called if the mesh changed.
virtual void recalculateBoundingBox() = 0;
//! returns position of vertex i
virtual const core::vector3df &getPosition(u32 i) const = 0;
//! returns position of vertex i
virtual core::vector3df &getPosition(u32 i) = 0;
//! returns normal of vertex i
virtual const core::vector3df &getNormal(u32 i) const = 0;
//! returns normal of vertex i
virtual core::vector3df &getNormal(u32 i) = 0;
//! returns texture coord of vertex i
virtual const core::vector2df &getTCoords(u32 i) const = 0;
//! returns texture coord of vertex i
virtual core::vector2df &getTCoords(u32 i) = 0;
//! Append the vertices and indices to the current buffer
/** Only works for compatible vertex types.
\param vertices Pointer to a vertex array.
\param numVertices Number of vertices in the array.
\param indices Pointer to index array.
\param numIndices Number of indices in array. */
virtual void append(const void *const vertices, u32 numVertices, const u16 *const indices, u32 numIndices) = 0;
//! get the current hardware mapping hint
virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const = 0;
//! get the current hardware mapping hint
virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const = 0;
//! set the hardware mapping hint, for driver
virtual void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer = EBT_VERTEX_AND_INDEX) = 0;
//! flags the meshbuffer as changed, reloads hardware buffers
virtual void setDirty(E_BUFFER_TYPE buffer = EBT_VERTEX_AND_INDEX) = 0;
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
virtual u32 getChangedID_Vertex() const = 0;
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
virtual u32 getChangedID_Index() const = 0;
//! Used by the VideoDriver to remember the buffer link.
virtual void setHWBuffer(void *ptr) const = 0;
virtual void *getHWBuffer() const = 0;
//! Describe what kind of primitive geometry is used by the meshbuffer
/** Note: Default is EPT_TRIANGLES. Using other types is fine for rendering.
But meshbuffer manipulation functions might expect type EPT_TRIANGLES
to work correctly. Also mesh writers will generally fail (badly!) with other
types than EPT_TRIANGLES. */
virtual void setPrimitiveType(E_PRIMITIVE_TYPE type) = 0;
//! Get the kind of primitive geometry which is used by the meshbuffer
virtual E_PRIMITIVE_TYPE getPrimitiveType() const = 0;
//! Calculate how many geometric primitives are used by this meshbuffer
virtual u32 getPrimitiveCount() const
{
const u32 indexCount = getIndexCount();
switch (getPrimitiveType()) {
case scene::EPT_POINTS:
return indexCount;
case scene::EPT_LINE_STRIP:
return indexCount - 1;
case scene::EPT_LINE_LOOP:
return indexCount;
case scene::EPT_LINES:
return indexCount / 2;
case scene::EPT_TRIANGLE_STRIP:
return (indexCount - 2);
case scene::EPT_TRIANGLE_FAN:
return (indexCount - 2);
case scene::EPT_TRIANGLES:
return indexCount / 3;
case scene::EPT_POINT_SPRITES:
return indexCount;
}
return 0;
}
};
} // end namespace scene
} // end namespace irr

131
irr/include/IMeshCache.h Normal file
View File

@ -0,0 +1,131 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "path.h"
namespace irr
{
namespace scene
{
class IMesh;
class IAnimatedMesh;
class IAnimatedMeshSceneNode;
class IMeshLoader;
//! The mesh cache stores already loaded meshes and provides an interface to them.
/** You can access it using ISceneManager::getMeshCache(). All existing
scene managers will return a pointer to the same mesh cache, because it
is shared between them. With this interface, it is possible to manually
add new loaded meshes (if ISceneManager::getMesh() is not sufficient),
to remove them and to iterate through already loaded meshes. */
class IMeshCache : public virtual IReferenceCounted
{
public:
//! Destructor
virtual ~IMeshCache() {}
//! Adds a mesh to the internal list of loaded meshes.
/** Usually, ISceneManager::getMesh() is called to load a mesh
from a file. That method searches the list of loaded meshes if
a mesh has already been loaded and returns a pointer to if it
is in that list and already in memory. Otherwise it loads the
mesh. With IMeshCache::addMesh(), it is possible to pretend
that a mesh already has been loaded. This method can be used
for example by mesh loaders who need to load more than one mesh
with one call. They can add additional meshes with this method
to the scene manager. The COLLADA loader for example uses this
method.
\param name Name of the mesh. When calling
ISceneManager::getMesh() with this name it will return the mesh
set by this method.
\param mesh Pointer to a mesh which will now be referenced by
this name. */
virtual void addMesh(const io::path &name, IAnimatedMesh *mesh) = 0;
//! Removes the mesh from the cache.
/** After loading a mesh with getMesh(), the mesh can be
removed from the cache using this method, freeing a lot of
memory.
\param mesh Pointer to the mesh which shall be removed. */
virtual void removeMesh(const IMesh *const mesh) = 0;
//! Returns amount of loaded meshes in the cache.
/** You can load new meshes into the cache using getMesh() and
addMesh(). If you ever need to access the internal mesh cache,
you can do this using removeMesh(), getMeshNumber(),
getMeshByIndex() and getMeshName().
\return Number of meshes in cache. */
virtual u32 getMeshCount() const = 0;
//! Returns current index number of the mesh or -1 when not found.
/** \param mesh Pointer to the mesh to search for.
\return Index of the mesh in the cache, or -1 if not found. */
virtual s32 getMeshIndex(const IMesh *const mesh) const = 0;
//! Returns a mesh based on its index number.
/** \param index: Index of the mesh, number between 0 and
getMeshCount()-1.
Note that this number is only valid until a new mesh is loaded
or removed.
\return Pointer to the mesh or 0 if there is none with this
number. */
virtual IAnimatedMesh *getMeshByIndex(u32 index) = 0;
//! Returns a mesh based on its name.
/** \param name Name of the mesh. Usually a filename.
\return Pointer to the mesh or 0 if there is none with this number. */
virtual IAnimatedMesh *getMeshByName(const io::path &name) = 0;
//! Get the name of a loaded mesh, based on its index.
/** \param index: Index of the mesh, number between 0 and getMeshCount()-1.
\return The name if mesh was found and has a name, else the path is empty. */
virtual const io::SNamedPath &getMeshName(u32 index) const = 0;
//! Get the name of the loaded mesh if there is any.
/** \param mesh Pointer to mesh to query.
\return The name if mesh was found and has a name, else the path is empty. */
virtual const io::SNamedPath &getMeshName(const IMesh *const mesh) const = 0;
//! Renames a loaded mesh.
/** Note that renaming meshes might change the ordering of the
meshes, and so the index of the meshes as returned by
getMeshIndex() or taken by some methods will change.
\param index The index of the mesh in the cache.
\param name New name for the mesh.
\return True if mesh was renamed. */
virtual bool renameMesh(u32 index, const io::path &name) = 0;
//! Renames the loaded mesh
/** Note that renaming meshes might change the ordering of the
meshes, and so the index of the meshes as returned by
getMeshIndex() or taken by some methods will change.
\param mesh Mesh to be renamed.
\param name New name for the mesh.
\return True if mesh was renamed. */
virtual bool renameMesh(const IMesh *const mesh, const io::path &name) = 0;
//! Check if a mesh was already loaded.
/** \param name Name of the mesh. Usually a filename.
\return True if the mesh has been loaded, else false. */
virtual bool isMeshLoaded(const io::path &name) = 0;
//! Clears the whole mesh cache, removing all meshes.
/** All meshes will be reloaded completely when using ISceneManager::getMesh()
after calling this method.
Warning: If you have pointers to meshes that were loaded with ISceneManager::getMesh()
and you did not grab them, then they may become invalid. */
virtual void clear() = 0;
//! Clears all meshes that are held in the mesh cache but not used anywhere else.
/** Warning: If you have pointers to meshes that were loaded with ISceneManager::getMesh()
and you did not grab them, then they may become invalid. */
virtual void clearUnusedMeshes() = 0;
};
} // end namespace scene
} // end namespace irr

50
irr/include/IMeshLoader.h Normal file
View File

@ -0,0 +1,50 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "path.h"
namespace irr
{
namespace io
{
class IReadFile;
} // end namespace io
namespace scene
{
class IAnimatedMesh;
//! Class which is able to load an animated mesh from a file.
/** If you want Irrlicht be able to load meshes of
currently unsupported file formats (e.g. .cob), then implement
this and add your new Meshloader with
ISceneManager::addExternalMeshLoader() to the engine. */
class IMeshLoader : public virtual IReferenceCounted
{
public:
//! Constructor
IMeshLoader() {}
//! Destructor
virtual ~IMeshLoader() {}
//! Returns true if the file might be loaded by this class.
/** This decision should be based on the file extension (e.g. ".cob")
only.
\param filename Name of the file to test.
\return True if the file might be loaded by this class. */
virtual bool isALoadableFileExtension(const io::path &filename) const = 0;
//! Creates/loads an animated mesh from the file.
/** \param file File handler to load the file from.
\return Pointer to the created mesh. Returns 0 if loading failed.
If you no longer need the mesh, you should call IAnimatedMesh::drop().
See IReferenceCounted::drop() for more information. */
virtual IAnimatedMesh *createMesh(io::IReadFile *file) = 0;
};
} // end namespace scene
} // end namespace irr

170
irr/include/IMeshManipulator.h Normal file
View File

@ -0,0 +1,170 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "vector3d.h"
#include "aabbox3d.h"
#include "matrix4.h"
#include "IAnimatedMesh.h"
#include "IMeshBuffer.h"
#include "SVertexManipulator.h"
namespace irr
{
namespace scene
{
struct SMesh;
//! An interface for easy manipulation of meshes.
/** Scale, set alpha value, flip surfaces, and so on. This exists for
fixing problems with wrong imported or exported meshes quickly after
loading. It is not intended for doing mesh modifications and/or
animations during runtime.
*/
class IMeshManipulator : public virtual IReferenceCounted
{
public:
//! Recalculates all normals of the mesh.
/** \param mesh: Mesh on which the operation is performed.
\param smooth: If the normals shall be smoothed.
\param angleWeighted: If the normals shall be smoothed in relation to their angles. More expensive, but also higher precision. */
virtual void recalculateNormals(IMesh *mesh, bool smooth = false,
bool angleWeighted = false) const = 0;
//! Recalculates all normals of the mesh buffer.
/** \param buffer: Mesh buffer on which the operation is performed.
\param smooth: If the normals shall be smoothed.
\param angleWeighted: If the normals shall be smoothed in relation to their angles. More expensive, but also higher precision. */
virtual void recalculateNormals(IMeshBuffer *buffer,
bool smooth = false, bool angleWeighted = false) const = 0;
//! Scales the actual mesh, not a scene node.
/** \param mesh Mesh on which the operation is performed.
\param factor Scale factor for each axis. */
void scale(IMesh *mesh, const core::vector3df &factor) const
{
apply(SVertexPositionScaleManipulator(factor), mesh, true);
}
//! Scales the actual meshbuffer, not a scene node.
/** \param buffer Meshbuffer on which the operation is performed.
\param factor Scale factor for each axis. */
void scale(IMeshBuffer *buffer, const core::vector3df &factor) const
{
apply(SVertexPositionScaleManipulator(factor), buffer, true);
}
//! Clones a static IMesh into a modifiable SMesh.
/** All meshbuffers in the returned SMesh
are of type SMeshBuffer or SMeshBufferLightMap.
\param mesh Mesh to copy.
\return Cloned mesh. If you no longer need the
cloned mesh, you should call SMesh::drop(). See
IReferenceCounted::drop() for more information. */
virtual SMesh *createMeshCopy(IMesh *mesh) const = 0;
//! Get amount of polygons in mesh.
/** \param mesh Input mesh
\return Number of polygons in mesh. */
virtual s32 getPolyCount(IMesh *mesh) const = 0;
//! Get amount of polygons in mesh.
/** \param mesh Input mesh
\return Number of polygons in mesh. */
virtual s32 getPolyCount(IAnimatedMesh *mesh) const = 0;
//! Create a new AnimatedMesh and adds the mesh to it
/** \param mesh Input mesh
\param type The type of the animated mesh to create.
\return Newly created animated mesh with mesh as its only
content. When you don't need the animated mesh anymore, you
should call IAnimatedMesh::drop(). See
IReferenceCounted::drop() for more information. */
virtual IAnimatedMesh *createAnimatedMesh(IMesh *mesh,
scene::E_ANIMATED_MESH_TYPE type = scene::EAMT_UNKNOWN) const = 0;
//! Apply a manipulator on the Meshbuffer
/** \param func A functor defining the mesh manipulation.
\param buffer The Meshbuffer to apply the manipulator to.
\param boundingBoxUpdate Specifies if the bounding box should be updated during manipulation.
\return True if the functor was successfully applied, else false. */
template <typename Functor>
bool apply(const Functor &func, IMeshBuffer *buffer, bool boundingBoxUpdate = false) const
{
return apply_(func, buffer, boundingBoxUpdate, func);
}
//! Apply a manipulator on the Mesh
/** \param func A functor defining the mesh manipulation.
\param mesh The Mesh to apply the manipulator to.
\param boundingBoxUpdate Specifies if the bounding box should be updated during manipulation.
\return True if the functor was successfully applied, else false. */
template <typename Functor>
bool apply(const Functor &func, IMesh *mesh, bool boundingBoxUpdate = false) const
{
if (!mesh)
return true;
bool result = true;
core::aabbox3df bufferbox;
for (u32 i = 0; i < mesh->getMeshBufferCount(); ++i) {
result &= apply(func, mesh->getMeshBuffer(i), boundingBoxUpdate);
if (boundingBoxUpdate) {
if (0 == i)
bufferbox.reset(mesh->getMeshBuffer(i)->getBoundingBox());
else
bufferbox.addInternalBox(mesh->getMeshBuffer(i)->getBoundingBox());
}
}
if (boundingBoxUpdate)
mesh->setBoundingBox(bufferbox);
return result;
}
protected:
//! Apply a manipulator based on the type of the functor
/** \param func A functor defining the mesh manipulation.
\param buffer The Meshbuffer to apply the manipulator to.
\param boundingBoxUpdate Specifies if the bounding box should be updated during manipulation.
\param typeTest Unused parameter, which handles the proper call selection based on the type of the Functor which is passed in two times.
\return True if the functor was successfully applied, else false. */
template <typename Functor>
bool apply_(const Functor &func, IMeshBuffer *buffer, bool boundingBoxUpdate, const IVertexManipulator &typeTest) const
{
if (!buffer)
return true;
core::aabbox3df bufferbox;
for (u32 i = 0; i < buffer->getVertexCount(); ++i) {
switch (buffer->getVertexType()) {
case video::EVT_STANDARD: {
video::S3DVertex *verts = (video::S3DVertex *)buffer->getVertices();
func(verts[i]);
} break;
case video::EVT_2TCOORDS: {
video::S3DVertex2TCoords *verts = (video::S3DVertex2TCoords *)buffer->getVertices();
func(verts[i]);
} break;
case video::EVT_TANGENTS: {
video::S3DVertexTangents *verts = (video::S3DVertexTangents *)buffer->getVertices();
func(verts[i]);
} break;
}
if (boundingBoxUpdate) {
if (0 == i)
bufferbox.reset(buffer->getPosition(0));
else
bufferbox.addInternalPoint(buffer->getPosition(i));
}
}
if (boundingBoxUpdate)
buffer->setBoundingBox(bufferbox);
return true;
}
};
} // end namespace scene
} // end namespace irr

50
irr/include/IMeshSceneNode.h Normal file
View File

@ -0,0 +1,50 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "ISceneNode.h"
namespace irr
{
namespace scene
{
class IMesh;
//! A scene node displaying a static mesh
class IMeshSceneNode : public ISceneNode
{
public:
//! Constructor
/** Use setMesh() to set the mesh to display.
*/
IMeshSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id,
const core::vector3df &position = core::vector3df(0, 0, 0),
const core::vector3df &rotation = core::vector3df(0, 0, 0),
const core::vector3df &scale = core::vector3df(1, 1, 1)) :
ISceneNode(parent, mgr, id, position, rotation, scale) {}
//! Sets a new mesh to display
/** \param mesh Mesh to display. */
virtual void setMesh(IMesh *mesh) = 0;
//! Get the currently defined mesh for display.
/** \return Pointer to mesh which is displayed by this node. */
virtual IMesh *getMesh(void) = 0;
//! Sets if the scene node should not copy the materials of the mesh but use them in a read only style.
/** In this way it is possible to change the materials of a mesh
causing all mesh scene nodes referencing this mesh to change, too.
\param readonly Flag if the materials shall be read-only. */
virtual void setReadOnlyMaterials(bool readonly) = 0;
//! Check if the scene node should not copy the materials of the mesh but use them in a read only style
/** This flag can be set by setReadOnlyMaterials().
\return Whether the materials are read-only. */
virtual bool isReadOnlyMaterials() const = 0;
};
} // end namespace scene
} // end namespace irr

45
irr/include/IOSOperator.h Normal file
View File

@ -0,0 +1,45 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "irrString.h"
namespace irr
{
//! The OSOperator provides OS-specific methods and information.
class IOSOperator : public virtual IReferenceCounted
{
public:
//! Get the current OS version as string.
virtual const core::stringc &getOperatingSystemVersion() const = 0;
//! Copies text to the clipboard
//! \param text: text in utf-8
virtual void copyToClipboard(const c8 *text) const = 0;
//! Copies text to the primary selection
//! This is a no-op on some platforms.
//! \param text: text in utf-8
virtual void copyToPrimarySelection(const c8 *text) const = 0;
//! Get text from the clipboard
//! \return Returns 0 if no string is in there, otherwise an utf-8 string.
virtual const c8 *getTextFromClipboard() const = 0;
//! Get text from the primary selection
//! This is a no-op on some platforms.
//! \return Returns 0 if no string is in there, otherwise an utf-8 string.
virtual const c8 *getTextFromPrimarySelection() const = 0;
//! Get the total and available system RAM
/** \param totalBytes: will contain the total system memory in Kilobytes (1024 B)
\param availableBytes: will contain the available memory in Kilobytes (1024 B)
\return True if successful, false if not */
virtual bool getSystemMemory(u32 *totalBytes, u32 *availableBytes) const = 0;
};
} // end namespace

57
irr/include/IReadFile.h Normal file
View File

@ -0,0 +1,57 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "coreutil.h"
#include "EReadFileType.h"
namespace irr
{
namespace io
{
//! Interface providing read access to a file.
class IReadFile : public virtual IReferenceCounted
{
public:
//! Reads an amount of bytes from the file.
/** \param buffer Pointer to buffer where read bytes are written to.
\param sizeToRead Amount of bytes to read from the file.
\return How many bytes were read. */
virtual size_t read(void *buffer, size_t sizeToRead) = 0;
//! Changes position in file
/** \param finalPos Destination position in the file.
\param relativeMovement If set to true, the position in the file is
changed relative to current position. Otherwise the position is changed
from beginning of file.
\return True if successful, otherwise false. */
virtual bool seek(long finalPos, bool relativeMovement = false) = 0;
//! Get size of file.
/** \return Size of the file in bytes. */
virtual long getSize() const = 0;
//! Get the current position in the file.
/** \return Current position in the file in bytes on success or -1L on failure. */
virtual long getPos() const = 0;
//! Get name of file.
/** \return File name as zero terminated character string. */
virtual const io::path &getFileName() const = 0;
//! Get the type of the class implementing this interface
virtual EREAD_FILE_TYPE getType() const
{
return EFIT_UNKNOWN;
}
};
//! Internal function, please do not use.
IReadFile *createLimitReadFile(const io::path &fileName, IReadFile *alreadyOpenedFile, long pos, long areaSize);
} // end namespace io
} // end namespace irr

162
irr/include/IReferenceCounted.h Normal file
View File

@ -0,0 +1,162 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "irrTypes.h"
namespace irr
{
//! Base class of most objects of the Irrlicht Engine.
/** This class provides reference counting through the methods grab() and drop().
It also is able to store a debug string for every instance of an object.
Most objects of the Irrlicht
Engine are derived from IReferenceCounted, and so they are reference counted.
When you create an object in the Irrlicht engine, calling a method
which starts with 'create', an object is created, and you get a pointer
to the new object. If you no longer need the object, you have
to call drop(). This will destroy the object, if grab() was not called
in another part of you program, because this part still needs the object.
Note, that you only need to call drop() to the object, if you created it,
and the method had a 'create' in it.
A simple example:
If you want to create a texture, you may want to call an imaginable method
IDriver::createTexture. You call
ITexture* texture = driver->createTexture(dimension2d<u32>(128, 128));
If you no longer need the texture, call texture->drop().
If you want to load a texture, you may want to call imaginable method
IDriver::loadTexture. You do this like
ITexture* texture = driver->loadTexture("example.jpg");
You will not have to drop the pointer to the loaded texture, because
the name of the method does not start with 'create'. The texture
is stored somewhere by the driver.
*/
class IReferenceCounted
{
public:
//! Constructor.
IReferenceCounted() :
DebugName(0), ReferenceCounter(1)
{
}
//! Destructor.
virtual ~IReferenceCounted()
{
}
//! Grabs the object. Increments the reference counter by one.
/** Someone who calls grab() to an object, should later also
call drop() to it. If an object never gets as much drop() as
grab() calls, it will never be destroyed. The
IReferenceCounted class provides a basic reference counting
mechanism with its methods grab() and drop(). Most objects of
the Irrlicht Engine are derived from IReferenceCounted, and so
they are reference counted.
When you create an object in the Irrlicht engine, calling a
method which starts with 'create', an object is created, and
you get a pointer to the new object. If you no longer need the
object, you have to call drop(). This will destroy the object,
if grab() was not called in another part of you program,
because this part still needs the object. Note, that you only
need to call drop() to the object, if you created it, and the
method had a 'create' in it.
A simple example:
If you want to create a texture, you may want to call an
imaginable method IDriver::createTexture. You call
ITexture* texture = driver->createTexture(dimension2d<u32>(128, 128));
If you no longer need the texture, call texture->drop().
If you want to load a texture, you may want to call imaginable
method IDriver::loadTexture. You do this like
ITexture* texture = driver->loadTexture("example.jpg");
You will not have to drop the pointer to the loaded texture,
because the name of the method does not start with 'create'.
The texture is stored somewhere by the driver. */
void grab() const { ++ReferenceCounter; }
//! Drops the object. Decrements the reference counter by one.
/** The IReferenceCounted class provides a basic reference
counting mechanism with its methods grab() and drop(). Most
objects of the Irrlicht Engine are derived from
IReferenceCounted, and so they are reference counted.
When you create an object in the Irrlicht engine, calling a
method which starts with 'create', an object is created, and
you get a pointer to the new object. If you no longer need the
object, you have to call drop(). This will destroy the object,
if grab() was not called in another part of you program,
because this part still needs the object. Note, that you only
need to call drop() to the object, if you created it, and the
method had a 'create' in it.
A simple example:
If you want to create a texture, you may want to call an
imaginable method IDriver::createTexture. You call
ITexture* texture = driver->createTexture(dimension2d<u32>(128, 128));
If you no longer need the texture, call texture->drop().
If you want to load a texture, you may want to call imaginable
method IDriver::loadTexture. You do this like
ITexture* texture = driver->loadTexture("example.jpg");
You will not have to drop the pointer to the loaded texture,
because the name of the method does not start with 'create'.
The texture is stored somewhere by the driver.
\return True, if the object was deleted. */
bool drop() const
{
// someone is doing bad reference counting.
_IRR_DEBUG_BREAK_IF(ReferenceCounter <= 0)
--ReferenceCounter;
if (!ReferenceCounter) {
delete this;
return true;
}
return false;
}
//! Get the reference count.
/** \return Current value of the reference counter. */
s32 getReferenceCount() const
{
return ReferenceCounter;
}
//! Returns the debug name of the object.
/** The Debugname may only be set and changed by the object
itself. This method should only be used in Debug mode.
\return Returns a string, previously set by setDebugName(); */
const c8 *getDebugName() const
{
return DebugName;
}
protected:
//! Sets the debug name of the object.
/** The Debugname may only be set and changed by the object
itself. This method should only be used in Debug mode.
\param newName: New debug name to set. */
void setDebugName(const c8 *newName)
{
DebugName = newName;
}
private:
//! The debug name.
const c8 *DebugName;
//! The reference counter. Mutable to do reference counting on const objects.
mutable s32 ReferenceCounter;
};
} // end namespace irr

119
irr/include/IRenderTarget.h Normal file
View File

@ -0,0 +1,119 @@
// Copyright (C) 2015 Patryk Nadrowski
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "EDriverTypes.h"
#include "irrArray.h"
namespace irr
{
namespace video
{
class ITexture;
//! Enumeration of cube texture surfaces
enum E_CUBE_SURFACE
{
ECS_POSX = 0,
ECS_NEGX,
ECS_POSY,
ECS_NEGY,
ECS_POSZ,
ECS_NEGZ
};
//! Interface of a Render Target.
class IRenderTarget : public virtual IReferenceCounted
{
public:
//! constructor
IRenderTarget() :
DepthStencil(0), DriverType(EDT_NULL)
{
}
//! Returns an array of previously set textures.
const core::array<ITexture *> &getTexture() const
{
return Textures;
}
//! Returns a of previously set depth / depth-stencil texture.
ITexture *getDepthStencil() const
{
return DepthStencil;
}
//! Returns an array of active surface for cube textures
const core::array<E_CUBE_SURFACE> &getCubeSurfaces() const
{
return CubeSurfaces;
}
//! Set multiple textures.
/** Set multiple textures for the render target.
\param texture Array of texture objects. These textures are used for a color outputs.
\param depthStencil Depth or packed depth-stencil texture. This texture is used as depth
or depth-stencil buffer. You can pass getDepthStencil() if you don't want to change it.
\param cubeSurfaces When rendering to cube textures, set the surface to be used for each texture. Can be empty otherwise.
*/
void setTexture(const core::array<ITexture *> &texture, ITexture *depthStencil, const core::array<E_CUBE_SURFACE> &cubeSurfaces = core::array<E_CUBE_SURFACE>())
{
setTextures(texture.const_pointer(), texture.size(), depthStencil, cubeSurfaces.const_pointer(), cubeSurfaces.size());
}
//! Sets one texture + depthStencil
//! You can pass getDepthStencil() for depthStencil if you don't want to change that one
void setTexture(ITexture *texture, ITexture *depthStencil)
{
if (texture) {
setTextures(&texture, 1, depthStencil);
} else {
setTextures(0, 0, depthStencil);
}
}
//! Set one cube surface texture.
void setTexture(ITexture *texture, ITexture *depthStencil, E_CUBE_SURFACE cubeSurface)
{
if (texture) {
setTextures(&texture, 1, depthStencil, &cubeSurface, 1);
} else {
setTextures(0, 0, depthStencil, &cubeSurface, 1);
}
}
//! Get driver type of render target.
E_DRIVER_TYPE getDriverType() const
{
return DriverType;
}
protected:
//! Set multiple textures.
// NOTE: working with pointers instead of arrays to avoid unnecessary memory allocations for the single textures case
virtual void setTextures(ITexture *const *textures, u32 numTextures, ITexture *depthStencil, const E_CUBE_SURFACE *cubeSurfaces = 0, u32 numCubeSurfaces = 0) = 0;
//! Textures assigned to render target.
core::array<ITexture *> Textures;
//! Depth or packed depth-stencil texture assigned to render target.
ITexture *DepthStencil;
//! Active surface of cube textures
core::array<E_CUBE_SURFACE> CubeSurfaces;
//! Driver type of render target.
E_DRIVER_TYPE DriverType;
private:
// no copying (IReferenceCounted still allows that for reasons which take some time to work around)
IRenderTarget(const IRenderTarget &);
IRenderTarget &operator=(const IRenderTarget &);
};
}
}

33
irr/include/ISceneCollisionManager.h Normal file
View File

@ -0,0 +1,33 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "position2d.h"
#include "line3d.h"
namespace irr
{
namespace scene
{
class ICameraSceneNode;
class ISceneCollisionManager : public virtual IReferenceCounted
{
public:
//! Returns a 3d ray which would go through the 2d screen coordinates.
/** \param pos: Screen coordinates in pixels.
\param camera: Camera from which the ray starts. If null, the
active camera is used.
\return Ray starting from the position of the camera and ending
at a length of the far value of the camera at a position which
would be behind the 2d screen coordinates. */
virtual core::line3d<f32> getRayFromScreenCoordinates(
const core::position2d<s32> &pos, const ICameraSceneNode *camera = 0) = 0;
};
} // end namespace scene
} // end namespace irr

632
irr/include/ISceneManager.h Normal file
View File

@ -0,0 +1,632 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "irrArray.h"
#include "irrString.h"
#include "path.h"
#include "vector3d.h"
#include "dimension2d.h"
#include "SColor.h"
#include "ESceneNodeTypes.h"
#include "SceneParameters.h"
#include "ISkinnedMesh.h"
namespace irr
{
struct SKeyMap;
struct SEvent;
namespace io
{
class IReadFile;
class IAttributes;
class IWriteFile;
class IFileSystem;
} // end namespace io
namespace gui
{
class IGUIFont;
class IGUIEnvironment;
} // end namespace gui
namespace video
{
class IVideoDriver;
class SMaterial;
class IImage;
class ITexture;
} // end namespace video
namespace scene
{
//! Enumeration for render passes.
/** A parameter passed to the registerNodeForRendering() method of the ISceneManager,
specifying when the node wants to be drawn in relation to the other nodes.
Note: Despite the numbering this is not used as bit-field.
*/
enum E_SCENE_NODE_RENDER_PASS
{
//! No pass currently active
ESNRP_NONE = 0,
//! Camera pass. The active view is set up here. The very first pass.
ESNRP_CAMERA = 1,
//! In this pass, lights are transformed into camera space and added to the driver
ESNRP_LIGHT = 2,
//! This is used for sky boxes.
ESNRP_SKY_BOX = 4,
//! All normal objects can use this for registering themselves.
/** This value will never be returned by
ISceneManager::getSceneNodeRenderPass(). The scene manager
will determine by itself if an object is transparent or solid
and register the object as ESNRT_TRANSPARENT or ESNRP_SOLID
automatically if you call registerNodeForRendering with this
value (which is default). Note that it will register the node
only as ONE type. If your scene node has both solid and
transparent material types register it twice (one time as
ESNRP_SOLID, the other time as ESNRT_TRANSPARENT) and in the
render() method call getSceneNodeRenderPass() to find out the
current render pass and render only the corresponding parts of
the node. */
ESNRP_AUTOMATIC = 24,
//! Solid scene nodes or special scene nodes without materials.
ESNRP_SOLID = 8,
//! Transparent scene nodes, drawn after solid nodes. They are sorted from back to front and drawn in that order.
ESNRP_TRANSPARENT = 16,
//! Transparent effect scene nodes, drawn after Transparent nodes. They are sorted from back to front and drawn in that order.
ESNRP_TRANSPARENT_EFFECT = 32,
//! Drawn after the solid nodes, before the transparent nodes, the time for drawing shadow volumes
ESNRP_SHADOW = 64,
//! Drawn after transparent effect nodes. For custom gui's. Unsorted (in order nodes registered themselves).
ESNRP_GUI = 128
};
class IAnimatedMesh;
class IAnimatedMeshSceneNode;
class IBillboardSceneNode;
class ICameraSceneNode;
class IDummyTransformationSceneNode;
class IMesh;
class IMeshBuffer;
class IMeshCache;
class ISceneCollisionManager;
class IMeshLoader;
class IMeshManipulator;
class IMeshSceneNode;
class ISceneNode;
class ISceneNodeFactory;
//! The Scene Manager manages scene nodes, mesh resources, cameras and all the other stuff.
/** All Scene nodes can be created only here.
A scene node is a node in the hierarchical scene graph. Every scene node
may have children, which are other scene nodes. Children move relative
the their parents position. If the parent of a node is not visible, its
children won't be visible, too. In this way, it is for example easily
possible to attach a light to a moving car or to place a walking
character on a moving platform on a moving ship.
The SceneManager is also able to load 3d mesh files of different
formats. Take a look at getMesh() to find out what formats are
supported. If these formats are not enough, use
addExternalMeshLoader() to add new formats to the engine.
*/
class ISceneManager : public virtual IReferenceCounted
{
public:
//! Get pointer to an animatable mesh. Loads the file if not loaded already.
/**
* If you want to remove a loaded mesh from the cache again, use removeMesh().
* Currently there are the following mesh formats supported:
* <TABLE border="1" cellpadding="2" cellspacing="0">
* <TR>
* <TD>Format</TD>
* <TD>Description</TD>
* </TR>
* <TR>
* <TD>3D Studio (.3ds)</TD>
* <TD>Loader for 3D-Studio files which lots of 3D packages
* are able to export. Only static meshes are currently
* supported by this importer.</TD>
* </TR>
* <TR>
* <TD>3D World Studio (.smf)</TD>
* <TD>Loader for Leadwerks SMF mesh files, a simple mesh format
* containing static geometry for games. The proprietary .STF texture format
* is not supported yet. This loader was originally written by Joseph Ellis. </TD>
* </TR>
* <TR>
* <TD>Bliz Basic B3D (.b3d)</TD>
* <TD>Loader for blitz basic files, developed by Mark
* Sibly. This is the ideal animated mesh format for game
* characters as it is both rigidly defined and widely
* supported by modeling and animation software.
* As this format supports skeletal animations, an
* ISkinnedMesh will be returned by this importer.</TD>
* </TR>
* <TR>
* <TD>Cartography shop 4 (.csm)</TD>
* <TD>Cartography Shop is a modeling program for creating
* architecture and calculating lighting. Irrlicht can
* directly import .csm files thanks to the IrrCSM library
* created by Saurav Mohapatra which is now integrated
* directly in Irrlicht.
* </TR>
* <TR>
* <TD>Delgine DeleD (.dmf)</TD>
* <TD>DeleD (delgine.com) is a 3D editor and level-editor
* combined into one and is specifically designed for 3D
* game-development. With this loader, it is possible to
* directly load all geometry is as well as textures and
* lightmaps from .dmf files. To set texture and
* material paths, see scene::DMF_USE_MATERIALS_DIRS.
* It is also possible to flip the alpha texture by setting
* scene::DMF_FLIP_ALPHA_TEXTURES to true and to set the
* material transparent reference value by setting
* scene::DMF_ALPHA_CHANNEL_REF to a float between 0 and
* 1. The loader is based on Salvatore Russo's .dmf
* loader, I just changed some parts of it. Thanks to
* Salvatore for his work and for allowing me to use his
* code in Irrlicht and put it under Irrlicht's license.
* For newer and more enhanced versions of the loader,
* take a look at delgine.com.
* </TD>
* </TR>
* <TR>
* <TD>DirectX (.x)</TD>
* <TD>Platform independent importer (so not D3D-only) for
* .x files. Most 3D packages can export these natively
* and there are several tools for them available, e.g.
* the Maya exporter included in the DX SDK.
* .x files can include skeletal animations and Irrlicht
* is able to play and display them, users can manipulate
* the joints via the ISkinnedMesh interface. Currently,
* Irrlicht only supports uncompressed .x files.</TD>
* </TR>
* <TR>
* <TD>Half-Life model (.mdl)</TD>
* <TD>This loader opens Half-life 1 models, it was contributed
* by Fabio Concas and adapted by Thomas Alten.</TD>
* </TR>
* <TR>
* <TD>LightWave (.lwo)</TD>
* <TD>Native to NewTek's LightWave 3D, the LWO format is well
* known and supported by many exporters. This loader will
* import LWO2 models including lightmaps, bumpmaps and
* reflection textures.</TD>
* </TR>
* <TR>
* <TD>Maya (.obj)</TD>
* <TD>Most 3D software can create .obj files which contain
* static geometry without material data. The material
* files .mtl are also supported. This importer for
* Irrlicht can load them directly. </TD>
* </TR>
* <TR>
* <TD>Milkshape (.ms3d)</TD>
* <TD>.MS3D files contain models and sometimes skeletal
* animations from the Milkshape 3D modeling and animation
* software. Like the other skeletal mesh loaders, joints
* are exposed via the ISkinnedMesh animated mesh type.</TD>
* </TR>
* <TR>
* <TD>My3D (.my3d)</TD>
* <TD>.my3D is a flexible 3D file format. The My3DTools
* contains plug-ins to export .my3D files from several
* 3D packages. With this built-in importer, Irrlicht
* can read and display those files directly. This
* loader was written by Zhuck Dimitry who also created
* the whole My3DTools package.
* </TD>
* </TR>
* <TR>
* <TD>OCT (.oct)</TD>
* <TD>The oct file format contains 3D geometry and
* lightmaps and can be loaded directly by Irrlicht. OCT
* files<br> can be created by FSRad, Paul Nette's
* radiosity processor or exported from Blender using
* OCTTools which can be found in the exporters/OCTTools
* directory of the SDK. Thanks to Murphy McCauley for
* creating all this.</TD>
* </TR>
* <TR>
* <TD>OGRE Meshes (.mesh)</TD>
* <TD>Ogre .mesh files contain 3D data for the OGRE 3D
* engine. Irrlicht can read and display them directly
* with this importer. To define materials for the mesh,
* copy a .material file named like the corresponding
* .mesh file where the .mesh file is. (For example
* ogrehead.material for ogrehead.mesh). Thanks to
* Christian Stehno who wrote and contributed this
* loader.</TD>
* </TR>
* <TR>
* <TD>Pulsar LMTools (.lmts)</TD>
* <TD>LMTools is a set of tools (Windows &amp; Linux) for
* creating lightmaps. Irrlicht can directly read .lmts
* files thanks to<br> the importer created by Jonas
* Petersen.
* Notes for<br> this version of the loader:<br>
* - It does not recognize/support user data in the
* *.lmts files.<br>
* - The TGAs generated by LMTools don't work in
* Irrlicht for some reason (the textures are upside
* down). Opening and resaving them in a graphics app
* will solve the problem.</TD>
* </TR>
* <TR>
* <TD>Quake 3 levels (.bsp)</TD>
* <TD>Quake 3 is a popular game by IDSoftware, and .pk3
* files contain .bsp files and textures/lightmaps
* describing huge prelighted levels. Irrlicht can read
* .pk3 and .bsp files directly and thus render Quake 3
* levels directly. Written by Nikolaus Gebhardt
* enhanced by Dean P. Macri with the curved surfaces
* feature. </TD>
* </TR>
* <TR>
* <TD>Quake 2 models (.md2)</TD>
* <TD>Quake 2 models are characters with morph target
* animation. Irrlicht can read, display and animate
* them directly with this importer. </TD>
* </TR>
* <TR>
* <TD>Quake 3 models (.md3)</TD>
* <TD>Quake 3 models are characters with morph target
* animation, they contain mount points for weapons and body
* parts and are typically made of several sections which are
* manually joined together.</TD>
* </TR>
* <TR>
* <TD>Stanford Triangle (.ply)</TD>
* <TD>Invented by Stanford University and known as the native
* format of the infamous "Stanford Bunny" model, this is a
* popular static mesh format used by 3D scanning hardware
* and software. This loader supports extremely large models
* in both ASCII and binary format, but only has rudimentary
* material support in the form of vertex colors and texture
* coordinates.</TD>
* </TR>
* <TR>
* <TD>Stereolithography (.stl)</TD>
* <TD>The STL format is used for rapid prototyping and
* computer-aided manufacturing, thus has no support for
* materials.</TD>
* </TR>
* </TABLE>
*
* To load and display a mesh quickly, just do this:
* \code
* SceneManager->addAnimatedMeshSceneNode(
* SceneManager->getMesh("yourmesh.3ds"));
* \endcode
* If you would like to implement and add your own file format loader to Irrlicht,
* see addExternalMeshLoader().
* \param file File handle of the mesh to load.
* \return Null if failed, otherwise pointer to the mesh.
* This pointer should not be dropped. See IReferenceCounted::drop() for more information.
**/
virtual IAnimatedMesh *getMesh(io::IReadFile *file) = 0;
//! Get interface to the mesh cache which is shared between all existing scene managers.
/** With this interface, it is possible to manually add new loaded
meshes (if ISceneManager::getMesh() is not sufficient), to remove them and to iterate
through already loaded meshes. */
virtual IMeshCache *getMeshCache() = 0;
//! Get the video driver.
/** \return Pointer to the video Driver.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual video::IVideoDriver *getVideoDriver() = 0;
//! Adds a scene node for rendering an animated mesh model.
/** \param mesh: Pointer to the loaded animated mesh to be displayed.
\param parent: Parent of the scene node. Can be NULL if no parent.
\param id: Id of the node. This id can be used to identify the scene node.
\param position: Position of the space relative to its parent where the
scene node will be placed.
\param rotation: Initial rotation of the scene node.
\param scale: Initial scale of the scene node.
\param alsoAddIfMeshPointerZero: Add the scene node even if a 0 pointer is passed.
\return Pointer to the created scene node.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual IAnimatedMeshSceneNode *addAnimatedMeshSceneNode(IAnimatedMesh *mesh,
ISceneNode *parent = 0, s32 id = -1,
const core::vector3df &position = core::vector3df(0, 0, 0),
const core::vector3df &rotation = core::vector3df(0, 0, 0),
const core::vector3df &scale = core::vector3df(1.0f, 1.0f, 1.0f),
bool alsoAddIfMeshPointerZero = false) = 0;
//! Adds a scene node for rendering a static mesh.
/** \param mesh: Pointer to the loaded static mesh to be displayed.
\param parent: Parent of the scene node. Can be NULL if no parent.
\param id: Id of the node. This id can be used to identify the scene node.
\param position: Position of the space relative to its parent where the
scene node will be placed.
\param rotation: Initial rotation of the scene node.
\param scale: Initial scale of the scene node.
\param alsoAddIfMeshPointerZero: Add the scene node even if a 0 pointer is passed.
\return Pointer to the created scene node.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual IMeshSceneNode *addMeshSceneNode(IMesh *mesh, ISceneNode *parent = 0, s32 id = -1,
const core::vector3df &position = core::vector3df(0, 0, 0),
const core::vector3df &rotation = core::vector3df(0, 0, 0),
const core::vector3df &scale = core::vector3df(1.0f, 1.0f, 1.0f),
bool alsoAddIfMeshPointerZero = false) = 0;
//! Adds a camera scene node to the scene graph and sets it as active camera.
/** This camera does not react on user input.
If you want to move or animate it, use ISceneNode::setPosition(),
ICameraSceneNode::setTarget() etc methods.
By default, a camera's look at position (set with setTarget()) and its scene node
rotation (set with setRotation()) are independent. If you want to be able to
control the direction that the camera looks by using setRotation() then call
ICameraSceneNode::bindTargetAndRotation(true) on it.
\param position: Position of the space relative to its parent where the camera will be placed.
\param lookat: Position where the camera will look at. Also known as target.
\param parent: Parent scene node of the camera. Can be null. If the parent moves,
the camera will move too.
\param id: id of the camera. This id can be used to identify the camera.
\param makeActive Flag whether this camera should become the active one.
Make sure you always have one active camera.
\return Pointer to interface to camera if successful, otherwise 0.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual ICameraSceneNode *addCameraSceneNode(ISceneNode *parent = 0,
const core::vector3df &position = core::vector3df(0, 0, 0),
const core::vector3df &lookat = core::vector3df(0, 0, 100),
s32 id = -1, bool makeActive = true) = 0;
//! Adds a billboard scene node to the scene graph.
/** A billboard is like a 3d sprite: A 2d element,
which always looks to the camera. It is usually used for things
like explosions, fire, lensflares and things like that.
\param parent Parent scene node of the billboard. Can be null.
If the parent moves, the billboard will move too.
\param size Size of the billboard. This size is 2 dimensional
because a billboard only has width and height.
\param position Position of the space relative to its parent
where the billboard will be placed.
\param id An id of the node. This id can be used to identify
the node.
\param colorTop The color of the vertices at the top of the
billboard (default: white).
\param colorBottom The color of the vertices at the bottom of
the billboard (default: white).
\return Pointer to the billboard if successful, otherwise NULL.
This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */
virtual IBillboardSceneNode *addBillboardSceneNode(ISceneNode *parent = 0,
const core::dimension2d<f32> &size = core::dimension2d<f32>(10.0f, 10.0f),
const core::vector3df &position = core::vector3df(0, 0, 0), s32 id = -1,
video::SColor colorTop = 0xFFFFFFFF, video::SColor colorBottom = 0xFFFFFFFF) = 0;
//! Adds an empty scene node to the scene graph.
/** Can be used for doing advanced transformations
or structuring the scene graph.
\return Pointer to the created scene node.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual ISceneNode *addEmptySceneNode(ISceneNode *parent = 0, s32 id = -1) = 0;
//! Adds a dummy transformation scene node to the scene graph.
/** This scene node does not render itself, and does not respond to set/getPosition,
set/getRotation and set/getScale. Its just a simple scene node that takes a
matrix as relative transformation, making it possible to insert any transformation
anywhere into the scene graph.
\return Pointer to the created scene node.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual IDummyTransformationSceneNode *addDummyTransformationSceneNode(
ISceneNode *parent = 0, s32 id = -1) = 0;
//! Gets the root scene node.
/** This is the scene node which is parent
of all scene nodes. The root scene node is a special scene node which
only exists to manage all scene nodes. It will not be rendered and cannot
be removed from the scene.
\return Pointer to the root scene node.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual ISceneNode *getRootSceneNode() = 0;
//! Get the first scene node with the specified id.
/** \param id: The id to search for
\param start: Scene node to start from. All children of this scene
node are searched. If null is specified, the root scene node is
taken.
\return Pointer to the first scene node with this id,
and null if no scene node could be found.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual ISceneNode *getSceneNodeFromId(s32 id, ISceneNode *start = 0) = 0;
//! Get the first scene node with the specified name.
/** \param name: The name to search for
\param start: Scene node to start from. All children of this scene
node are searched. If null is specified, the root scene node is
taken.
\return Pointer to the first scene node with this id,
and null if no scene node could be found.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual ISceneNode *getSceneNodeFromName(const c8 *name, ISceneNode *start = 0) = 0;
//! Get the first scene node with the specified type.
/** \param type: The type to search for
\param start: Scene node to start from. All children of this scene
node are searched. If null is specified, the root scene node is
taken.
\return Pointer to the first scene node with this type,
and null if no scene node could be found.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual ISceneNode *getSceneNodeFromType(scene::ESCENE_NODE_TYPE type, ISceneNode *start = 0) = 0;
//! Get scene nodes by type.
/** \param type: Type of scene node to find (ESNT_ANY will return all child nodes).
\param outNodes: results will be added to this array (outNodes is not cleared).
\param start: Scene node to start from. This node and all children of this scene
node are checked (recursively, so also children of children, etc). If null is specified,
the root scene node is taken as start-node. */
virtual void getSceneNodesFromType(ESCENE_NODE_TYPE type,
core::array<scene::ISceneNode *> &outNodes,
ISceneNode *start = 0) = 0;
//! Get the current active camera.
/** \return The active camera is returned. Note that this can
be NULL, if there was no camera created yet.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual ICameraSceneNode *getActiveCamera() const = 0;
//! Sets the currently active camera.
/** The previous active camera will be deactivated.
\param camera: The new camera which should be active. */
virtual void setActiveCamera(ICameraSceneNode *camera) = 0;
//! Registers a node for rendering it at a specific time.
/** This method should only be used by SceneNodes when they get a
ISceneNode::OnRegisterSceneNode() call.
\param node: Node to register for drawing. Usually scene nodes would set 'this'
as parameter here because they want to be drawn.
\param pass: Specifies when the node wants to be drawn in relation to the other nodes.
For example, if the node is a shadow, it usually wants to be drawn after all other nodes
and will use ESNRP_SHADOW for this. See scene::E_SCENE_NODE_RENDER_PASS for details.
Note: This is _not_ a bitfield. If you want to register a note for several render passes, then
call this function once for each pass.
\return scene will be rendered ( passed culling ) */
virtual u32 registerNodeForRendering(ISceneNode *node,
E_SCENE_NODE_RENDER_PASS pass = ESNRP_AUTOMATIC) = 0;
//! Clear all nodes which are currently registered for rendering
/** Usually you don't have to care about this as drawAll will clear nodes
after rendering them. But sometimes you might have to manually reset this.
For example when you deleted nodes between registering and rendering. */
virtual void clearAllRegisteredNodesForRendering() = 0;
//! Draws all the scene nodes.
/** This can only be invoked between
IVideoDriver::beginScene() and IVideoDriver::endScene(). Please note that
the scene is not only drawn when calling this, but also animated
by existing scene node animators, culling of scene nodes is done, etc. */
virtual void drawAll() = 0;
//! Adds an external mesh loader for extending the engine with new file formats.
/** If you want the engine to be extended with
file formats it currently is not able to load (e.g. .cob), just implement
the IMeshLoader interface in your loading class and add it with this method.
Using this method it is also possible to override built-in mesh loaders with
newer or updated versions without the need to recompile the engine.
\param externalLoader: Implementation of a new mesh loader. */
virtual void addExternalMeshLoader(IMeshLoader *externalLoader) = 0;
//! Returns the number of mesh loaders supported by Irrlicht at this time
virtual u32 getMeshLoaderCount() const = 0;
//! Retrieve the given mesh loader
/** \param index The index of the loader to retrieve. This parameter is an 0-based
array index.
\return A pointer to the specified loader, 0 if the index is incorrect. */
virtual IMeshLoader *getMeshLoader(u32 index) const = 0;
//! Get pointer to the scene collision manager.
/** \return Pointer to the collision manager
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual ISceneCollisionManager *getSceneCollisionManager() = 0;
//! Get pointer to the mesh manipulator.
/** \return Pointer to the mesh manipulator
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual IMeshManipulator *getMeshManipulator() = 0;
//! Adds a scene node to the deletion queue.
/** The scene node is immediately
deleted when it's secure. Which means when the scene node does not
execute animators and things like that. This method is for example
used for deleting scene nodes by their scene node animators. In
most other cases, a ISceneNode::remove() call is enough, using this
deletion queue is not necessary.
See ISceneManager::createDeleteAnimator() for details.
\param node: Node to delete. */
virtual void addToDeletionQueue(ISceneNode *node) = 0;
//! Posts an input event to the environment.
/** Usually you do not have to
use this method, it is used by the internal engine. */
virtual bool postEventFromUser(const SEvent &event) = 0;
//! Clears the whole scene.
/** All scene nodes are removed. */
virtual void clear() = 0;
//! Get interface to the parameters set in this scene.
/** String parameters can be used by plugins and mesh loaders.
See COLLADA_CREATE_SCENE_INSTANCES and DMF_USE_MATERIALS_DIRS */
virtual io::IAttributes *getParameters() = 0;
//! Get current render pass.
/** All scene nodes are being rendered in a specific order.
First lights, cameras, sky boxes, solid geometry, and then transparent
stuff. During the rendering process, scene nodes may want to know what the scene
manager is rendering currently, because for example they registered for rendering
twice, once for transparent geometry and once for solid. When knowing what rendering
pass currently is active they can render the correct part of their geometry. */
virtual E_SCENE_NODE_RENDER_PASS getSceneNodeRenderPass() const = 0;
//! Creates a new scene manager.
/** This can be used to easily draw and/or store two
independent scenes at the same time. The mesh cache will be
shared between all existing scene managers, which means if you
load a mesh in the original scene manager using for example
getMesh(), the mesh will be available in all other scene
managers too, without loading.
The original/main scene manager will still be there and
accessible via IrrlichtDevice::getSceneManager(). If you need
input event in this new scene manager, for example for FPS
cameras, you'll need to forward input to this manually: Just
implement an IEventReceiver and call
yourNewSceneManager->postEventFromUser(), and return true so
that the original scene manager doesn't get the event.
Otherwise, all input will go to the main scene manager
automatically.
If you no longer need the new scene manager, you should call
ISceneManager::drop().
See IReferenceCounted::drop() for more information. */
virtual ISceneManager *createNewSceneManager(bool cloneContent = false) = 0;
//! Get a skinned mesh, which is not available as header-only code
/** Note: You need to drop() the pointer after use again, see IReferenceCounted::drop()
for details. */
virtual ISkinnedMesh *createSkinnedMesh() = 0;
//! Sets ambient color of the scene
virtual void setAmbientLight(const video::SColorf &ambientColor) = 0;
//! Get ambient color of the scene
virtual const video::SColorf &getAmbientLight() const = 0;
//! Get current render pass.
virtual E_SCENE_NODE_RENDER_PASS getCurrentRenderPass() const = 0;
//! Set current render pass.
virtual void setCurrentRenderPass(E_SCENE_NODE_RENDER_PASS nextPass) = 0;
//! Check if node is culled in current view frustum
/** Please note that depending on the used culling method this
check can be rather coarse, or slow. A positive result is
correct, though, i.e. if this method returns true the node is
positively not visible. The node might still be invisible even
if this method returns false.
\param node The scene node which is checked for culling.
\return True if node is not visible in the current scene, else
false. */
virtual bool isCulled(const ISceneNode *node) const = 0;
};
} // end namespace scene
} // end namespace irr

597
irr/include/ISceneNode.h Normal file
View File

@ -0,0 +1,597 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "ESceneNodeTypes.h"
#include "ECullingTypes.h"
#include "EDebugSceneTypes.h"
#include "SMaterial.h"
#include "irrString.h"
#include "aabbox3d.h"
#include "matrix4.h"
#include "IAttributes.h"
#include <list>
#include <optional>
namespace irr
{
namespace scene
{
class ISceneNode;
class ISceneManager;
//! Typedef for list of scene nodes
typedef std::list<ISceneNode *> ISceneNodeList;
//! Scene node interface.
/** A scene node is a node in the hierarchical scene graph. Every scene
node may have children, which are also scene nodes. Children move
relative to their parent's position. If the parent of a node is not
visible, its children won't be visible either. In this way, it is for
example easily possible to attach a light to a moving car, or to place
a walking character on a moving platform on a moving ship.
*/
class ISceneNode : virtual public IReferenceCounted
{
public:
//! Constructor
ISceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id = -1,
const core::vector3df &position = core::vector3df(0, 0, 0),
const core::vector3df &rotation = core::vector3df(0, 0, 0),
const core::vector3df &scale = core::vector3df(1.0f, 1.0f, 1.0f)) :
RelativeTranslation(position),
RelativeRotation(rotation), RelativeScale(scale),
Parent(0), SceneManager(mgr), ID(id),
AutomaticCullingState(EAC_BOX), DebugDataVisible(EDS_OFF),
IsVisible(true), IsDebugObject(false)
{
if (parent)
parent->addChild(this);
updateAbsolutePosition();
}
//! Destructor
virtual ~ISceneNode()
{
// delete all children
removeAll();
}
//! This method is called just before the rendering process of the whole scene.
/** Nodes may register themselves in the render pipeline during this call,
precalculate the geometry which should be rendered, and prevent their
children from being able to register themselves if they are clipped by simply
not calling their OnRegisterSceneNode method.
If you are implementing your own scene node, you should overwrite this method
with an implementation code looking like this:
\code
if (IsVisible)
SceneManager->registerNodeForRendering(this);
ISceneNode::OnRegisterSceneNode();
\endcode
*/
virtual void OnRegisterSceneNode()
{
if (IsVisible) {
ISceneNodeList::iterator it = Children.begin();
for (; it != Children.end(); ++it)
(*it)->OnRegisterSceneNode();
}
}
//! OnAnimate() is called just before rendering the whole scene.
/** Nodes may calculate or store animations here, and may do other useful things,
depending on what they are. Also, OnAnimate() should be called for all
child scene nodes here. This method will be called once per frame, independent
of whether the scene node is visible or not.
\param timeMs Current time in milliseconds. */
virtual void OnAnimate(u32 timeMs)
{
if (IsVisible) {
// update absolute position
updateAbsolutePosition();
// perform the post render process on all children
ISceneNodeList::iterator it = Children.begin();
for (; it != Children.end(); ++it)
(*it)->OnAnimate(timeMs);
}
}
//! Renders the node.
virtual void render() = 0;
//! Returns the name of the node.
/** \return Name as character string. */
virtual const std::optional<std::string> &getName() const
{
return Name;
}
//! Sets the name of the node.
/** \param name New name of the scene node. */
virtual void setName(const std::optional<std::string> &name)
{
Name = name;
}
//! Get the axis aligned, not transformed bounding box of this node.
/** This means that if this node is an animated 3d character,
moving in a room, the bounding box will always be around the
origin. To get the box in real world coordinates, just
transform it with the matrix you receive with
getAbsoluteTransformation() or simply use
getTransformedBoundingBox(), which does the same.
\return The non-transformed bounding box. */
virtual const core::aabbox3d<f32> &getBoundingBox() const = 0;
//! Get the axis aligned, transformed and animated absolute bounding box of this node.
/** Note: The result is still an axis-aligned bounding box, so it's size
changes with rotation.
\return The transformed bounding box. */
virtual const core::aabbox3d<f32> getTransformedBoundingBox() const
{
core::aabbox3d<f32> box = getBoundingBox();
AbsoluteTransformation.transformBoxEx(box);
return box;
}
//! Get a the 8 corners of the original bounding box transformed and
//! animated by the absolute transformation.
/** Note: The result is _not_ identical to getTransformedBoundingBox().getEdges(),
but getting an aabbox3d of these edges would then be identical.
\param edges Receives an array with the transformed edges */
virtual void getTransformedBoundingBoxEdges(core::array<core::vector3d<f32>> &edges) const
{
edges.set_used(8);
getBoundingBox().getEdges(edges.pointer());
for (u32 i = 0; i < 8; ++i)
AbsoluteTransformation.transformVect(edges[i]);
}
//! Get the absolute transformation of the node. Is recalculated every OnAnimate()-call.
/** NOTE: For speed reasons the absolute transformation is not
automatically recalculated on each change of the relative
transformation or by a transformation change of an parent. Instead the
update usually happens once per frame in OnAnimate. You can enforce
an update with updateAbsolutePosition().
\return The absolute transformation matrix. */
virtual const core::matrix4 &getAbsoluteTransformation() const
{
return AbsoluteTransformation;
}
//! Returns the relative transformation of the scene node.
/** The relative transformation is stored internally as 3
vectors: translation, rotation and scale. To get the relative
transformation matrix, it is calculated from these values.
\return The relative transformation matrix. */
virtual core::matrix4 getRelativeTransformation() const
{
core::matrix4 mat;
mat.setRotationDegrees(RelativeRotation);
mat.setTranslation(RelativeTranslation);
if (RelativeScale != core::vector3df(1.f, 1.f, 1.f)) {
core::matrix4 smat;
smat.setScale(RelativeScale);
mat *= smat;
}
return mat;
}
//! Returns whether the node should be visible (if all of its parents are visible).
/** This is only an option set by the user, but has nothing to
do with geometry culling
\return The requested visibility of the node, true means
visible (if all parents are also visible). */
virtual bool isVisible() const
{
return IsVisible;
}
//! Check whether the node is truly visible, taking into accounts its parents' visibility
/** \return true if the node and all its parents are visible,
false if this or any parent node is invisible. */
virtual bool isTrulyVisible() const
{
if (!IsVisible)
return false;
if (!Parent)
return true;
return Parent->isTrulyVisible();
}
//! Sets if the node should be visible or not.
/** All children of this node won't be visible either, when set
to false. Invisible nodes are not valid candidates for selection by
collision manager bounding box methods.
\param isVisible If the node shall be visible. */
virtual void setVisible(bool isVisible)
{
IsVisible = isVisible;
}
//! Get the id of the scene node.
/** This id can be used to identify the node.
\return The id. */
virtual s32 getID() const
{
return ID;
}
//! Sets the id of the scene node.
/** This id can be used to identify the node.
\param id The new id. */
virtual void setID(s32 id)
{
ID = id;
}
//! Adds a child to this scene node.
/** If the scene node already has a parent it is first removed
from the other parent.
\param child A pointer to the new child. */
virtual void addChild(ISceneNode *child)
{
if (child && (child != this)) {
// Change scene manager?
if (SceneManager != child->SceneManager)
child->setSceneManager(SceneManager);
child->grab();
child->remove(); // remove from old parent
// Note: This iterator is not invalidated until we erase it.
child->ThisIterator = Children.insert(Children.end(), child);
child->Parent = this;
}
}
//! Removes a child from this scene node.
/**
\param child A pointer to the child which shall be removed.
\return True if the child was removed, and false if not,
e.g. because it belongs to a different parent or no parent. */
virtual bool removeChild(ISceneNode *child)
{
if (child->Parent != this)
return false;
// The iterator must be set since the parent is not null.
_IRR_DEBUG_BREAK_IF(!child->ThisIterator.has_value());
auto it = *child->ThisIterator;
child->ThisIterator = std::nullopt;
child->Parent = nullptr;
child->drop();
Children.erase(it);
return true;
}
//! Removes all children of this scene node
/** The scene nodes found in the children list are also dropped
and might be deleted if no other grab exists on them.
*/
virtual void removeAll()
{
for (auto &child : Children) {
child->Parent = nullptr;
child->ThisIterator = std::nullopt;
child->drop();
}
Children.clear();
}
//! Removes this scene node from the scene
/** If no other grab exists for this node, it will be deleted.
*/
virtual void remove()
{
if (Parent)
Parent->removeChild(this);
}
//! Returns the material based on the zero based index i.
/** To get the amount of materials used by this scene node, use
getMaterialCount(). This function is needed for inserting the
node into the scene hierarchy at an optimal position for
minimizing renderstate changes, but can also be used to
directly modify the material of a scene node.
\param num Zero based index. The maximal value is getMaterialCount() - 1.
\return The material at that index. */
virtual video::SMaterial &getMaterial(u32 num)
{
return video::IdentityMaterial;
}
//! Get amount of materials used by this scene node.
/** \return Current amount of materials of this scene node. */
virtual u32 getMaterialCount() const
{
return 0;
}
//! Execute a function on all materials of this scene node.
/** Useful for setting material properties, e.g. if you want the whole
mesh to be affected by light. */
template <typename F>
void forEachMaterial(F &&fn)
{
for (u32 i = 0; i < getMaterialCount(); i++) {
fn(getMaterial(i));
}
}
//! Gets the scale of the scene node relative to its parent.
/** This is the scale of this node relative to its parent.
If you want the absolute scale, use
getAbsoluteTransformation().getScale()
\return The scale of the scene node. */
virtual const core::vector3df &getScale() const
{
return RelativeScale;
}
//! Sets the relative scale of the scene node.
/** \param scale New scale of the node, relative to its parent. */
virtual void setScale(const core::vector3df &scale)
{
RelativeScale = scale;
}
//! Gets the rotation of the node relative to its parent.
/** Note that this is the relative rotation of the node.
If you want the absolute rotation, use
getAbsoluteTransformation().getRotation()
\return Current relative rotation of the scene node. */
virtual const core::vector3df &getRotation() const
{
return RelativeRotation;
}
//! Sets the rotation of the node relative to its parent.
/** This only modifies the relative rotation of the node.
\param rotation New rotation of the node in degrees. */
virtual void setRotation(const core::vector3df &rotation)
{
RelativeRotation = rotation;
}
//! Gets the position of the node relative to its parent.
/** Note that the position is relative to the parent. If you want
the position in world coordinates, use getAbsolutePosition() instead.
\return The current position of the node relative to the parent. */
virtual const core::vector3df &getPosition() const
{
return RelativeTranslation;
}
//! Sets the position of the node relative to its parent.
/** Note that the position is relative to the parent.
\param newpos New relative position of the scene node. */
virtual void setPosition(const core::vector3df &newpos)
{
RelativeTranslation = newpos;
}
//! Gets the absolute position of the node in world coordinates.
/** If you want the position of the node relative to its parent,
use getPosition() instead.
NOTE: For speed reasons the absolute position is not
automatically recalculated on each change of the relative
position or by a position change of an parent. Instead the
update usually happens once per frame in OnAnimate. You can enforce
an update with updateAbsolutePosition().
\return The current absolute position of the scene node (updated on last call of updateAbsolutePosition). */
virtual core::vector3df getAbsolutePosition() const
{
return AbsoluteTransformation.getTranslation();
}
//! Set a culling style or disable culling completely.
/** Box cullling (EAC_BOX) is set by default. Note that not
all SceneNodes support culling and that some nodes always cull
their geometry because it is their only reason for existence,
for example the OctreeSceneNode.
\param state The culling state to be used. Check E_CULLING_TYPE for possible values.*/
void setAutomaticCulling(u32 state)
{
AutomaticCullingState = state;
}
//! Gets the automatic culling state.
/** \return The automatic culling state. */
u32 getAutomaticCulling() const
{
return AutomaticCullingState;
}
//! Sets if debug data like bounding boxes should be drawn.
/** A bitwise OR of the types from @ref irr::scene::E_DEBUG_SCENE_TYPE.
Please note that not all scene nodes support all debug data types.
\param state The debug data visibility state to be used. */
virtual void setDebugDataVisible(u32 state)
{
DebugDataVisible = state;
}
//! Returns if debug data like bounding boxes are drawn.
/** \return A bitwise OR of the debug data values from
@ref irr::scene::E_DEBUG_SCENE_TYPE that are currently visible. */
u32 isDebugDataVisible() const
{
return DebugDataVisible;
}
//! Sets if this scene node is a debug object.
/** Debug objects have some special properties, for example they can be easily
excluded from collision detection or from serialization, etc. */
void setIsDebugObject(bool debugObject)
{
IsDebugObject = debugObject;
}
//! Returns if this scene node is a debug object.
/** Debug objects have some special properties, for example they can be easily
excluded from collision detection or from serialization, etc.
\return If this node is a debug object, true is returned. */
bool isDebugObject() const
{
return IsDebugObject;
}
//! Returns a const reference to the list of all children.
/** \return The list of all children of this node. */
const std::list<ISceneNode *> &getChildren() const
{
return Children;
}
//! Changes the parent of the scene node.
/** \param newParent The new parent to be used. */
virtual void setParent(ISceneNode *newParent)
{
grab();
remove();
if (newParent)
newParent->addChild(this);
drop();
}
//! Updates the absolute position based on the relative and the parents position
/** Note: This does not recursively update the parents absolute positions, so if you have a deeper
hierarchy you might want to update the parents first.*/
virtual void updateAbsolutePosition()
{
if (Parent) {
AbsoluteTransformation =
Parent->getAbsoluteTransformation() * getRelativeTransformation();
} else
AbsoluteTransformation = getRelativeTransformation();
}
//! Returns the parent of this scene node
/** \return A pointer to the parent. */
scene::ISceneNode *getParent() const
{
return Parent;
}
//! Returns type of the scene node
/** \return The type of this node. */
virtual ESCENE_NODE_TYPE getType() const
{
return ESNT_UNKNOWN;
}
//! Creates a clone of this scene node and its children.
/** \param newParent An optional new parent.
\param newManager An optional new scene manager.
\return The newly created clone of this node. */
virtual ISceneNode *clone(ISceneNode *newParent = 0, ISceneManager *newManager = 0)
{
return 0; // to be implemented by derived classes
}
//! Retrieve the scene manager for this node.
/** \return The node's scene manager. */
virtual ISceneManager *getSceneManager(void) const { return SceneManager; }
protected:
//! A clone function for the ISceneNode members.
/** This method can be used by clone() implementations of
derived classes
\param toCopyFrom The node from which the values are copied
\param newManager The new scene manager. */
void cloneMembers(ISceneNode *toCopyFrom, ISceneManager *newManager)
{
Name = toCopyFrom->Name;
AbsoluteTransformation = toCopyFrom->AbsoluteTransformation;
RelativeTranslation = toCopyFrom->RelativeTranslation;
RelativeRotation = toCopyFrom->RelativeRotation;
RelativeScale = toCopyFrom->RelativeScale;
ID = toCopyFrom->ID;
AutomaticCullingState = toCopyFrom->AutomaticCullingState;
DebugDataVisible = toCopyFrom->DebugDataVisible;
IsVisible = toCopyFrom->IsVisible;
IsDebugObject = toCopyFrom->IsDebugObject;
if (newManager)
SceneManager = newManager;
else
SceneManager = toCopyFrom->SceneManager;
// clone children
ISceneNodeList::iterator it = toCopyFrom->Children.begin();
for (; it != toCopyFrom->Children.end(); ++it)
(*it)->clone(this, newManager);
}
//! Sets the new scene manager for this node and all children.
//! Called by addChild when moving nodes between scene managers
void setSceneManager(ISceneManager *newManager)
{
SceneManager = newManager;
ISceneNodeList::iterator it = Children.begin();
for (; it != Children.end(); ++it)
(*it)->setSceneManager(newManager);
}
//! Name of the scene node.
std::optional<std::string> Name;
//! Absolute transformation of the node.
core::matrix4 AbsoluteTransformation;
//! Relative translation of the scene node.
core::vector3df RelativeTranslation;
//! Relative rotation of the scene node.
core::vector3df RelativeRotation;
//! Relative scale of the scene node.
core::vector3df RelativeScale;
//! List of all children of this node
std::list<ISceneNode *> Children;
//! Iterator pointing to this node in the parent's child list.
std::optional<ISceneNodeList::iterator> ThisIterator;
//! Pointer to the parent
ISceneNode *Parent;
//! Pointer to the scene manager
ISceneManager *SceneManager;
//! ID of the node.
s32 ID;
//! Automatic culling state
u32 AutomaticCullingState;
//! Flag if debug data should be drawn, such as Bounding Boxes.
u32 DebugDataVisible;
//! Is the node visible?
bool IsVisible;
//! Is debug object?
bool IsDebugObject;
};
} // end namespace scene
} // end namespace irr

79
irr/include/IShaderConstantSetCallBack.h Normal file
View File

@ -0,0 +1,79 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
namespace irr
{
namespace video
{
class IMaterialRendererServices;
class SMaterial;
//! Interface making it possible to set constants for gpu programs every frame.
/** Implement this interface in an own class and pass a pointer to it to one of
the methods in IGPUProgrammingServices when creating a shader. The
OnSetConstants method will be called every frame now. */
class IShaderConstantSetCallBack : public virtual IReferenceCounted
{
public:
//! Called to let the callBack know the used material (optional method)
/**
\code
class MyCallBack : public IShaderConstantSetCallBack
{
const video::SMaterial *UsedMaterial;
OnSetMaterial(const video::SMaterial& material)
{
UsedMaterial=&material;
}
OnSetConstants(IMaterialRendererServices* services, s32 userData)
{
services->setVertexShaderConstant("myColor", reinterpret_cast<f32*>(&UsedMaterial->color), 4);
}
}
\endcode
*/
virtual void OnSetMaterial(const SMaterial &material) {}
//! Called by the engine when the vertex and/or pixel shader constants for an material renderer should be set.
/**
Implement the IShaderConstantSetCallBack in an own class and implement your own
OnSetConstants method using the given IMaterialRendererServices interface.
Pass a pointer to this class to one of the methods in IGPUProgrammingServices
when creating a shader. The OnSetConstants method will now be called every time
before geometry is being drawn using your shader material. A sample implementation
would look like this:
\code
virtual void OnSetConstants(video::IMaterialRendererServices* services, s32 userData)
{
video::IVideoDriver* driver = services->getVideoDriver();
// set clip matrix at register 4
core::matrix4 worldViewProj(driver->getTransform(video::ETS_PROJECTION));
worldViewProj *= driver->getTransform(video::ETS_VIEW);
worldViewProj *= driver->getTransform(video::ETS_WORLD);
services->setVertexShaderConstant(&worldViewProj.M[0], 4, 4);
// for high level shading languages, this would be another solution:
//services->setVertexShaderConstant("mWorldViewProj", worldViewProj.M, 16);
// set some light color at register 9
video::SColorf col(0.0f,1.0f,1.0f,0.0f);
services->setVertexShaderConstant(reinterpret_cast<const f32*>(&col), 9, 1);
// for high level shading languages, this would be another solution:
//services->setVertexShaderConstant("myColor", reinterpret_cast<f32*>(&col), 4);
}
\endcode
\param services: Pointer to an interface providing methods to set the constants for the shader.
\param userData: Userdata int which can be specified when creating the shader.
*/
virtual void OnSetConstants(IMaterialRendererServices *services, s32 userData) = 0;
};
} // end namespace video
} // end namespace irr

220
irr/include/ISkinnedMesh.h Normal file
View File

@ -0,0 +1,220 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "irrArray.h"
#include "IBoneSceneNode.h"
#include "IAnimatedMesh.h"
#include "SSkinMeshBuffer.h"
#include <optional>
namespace irr
{
namespace scene
{
enum E_INTERPOLATION_MODE
{
// constant does use the current key-values without interpolation
EIM_CONSTANT = 0,
// linear interpolation
EIM_LINEAR,
//! count of all available interpolation modes
EIM_COUNT
};
//! Interface for using some special functions of Skinned meshes
class ISkinnedMesh : public IAnimatedMesh
{
public:
//! Gets joint count.
/** \return Amount of joints in the skeletal animated mesh. */
virtual u32 getJointCount() const = 0;
//! Gets the name of a joint.
/** \param number: Zero based index of joint. The last joint
has the number getJointCount()-1;
\return Name of joint and null if an error happened. */
virtual const std::optional<std::string> &getJointName(u32 number) const = 0;
//! Gets a joint number from its name
/** \param name: Name of the joint.
\return Number of the joint or std::nullopt if not found. */
virtual std::optional<u32> getJointNumber(const std::string &name) const = 0;
//! Use animation from another mesh
/** The animation is linked (not copied) based on joint names
so make sure they are unique.
\return True if all joints in this mesh were
matched up (empty names will not be matched, and it's case
sensitive). Unmatched joints will not be animated. */
virtual bool useAnimationFrom(const ISkinnedMesh *mesh) = 0;
//! Update Normals when Animating
/** \param on If false don't animate, which is faster.
Else update normals, which allows for proper lighting of
animated meshes. */
virtual void updateNormalsWhenAnimating(bool on) = 0;
//! Sets Interpolation Mode
virtual void setInterpolationMode(E_INTERPOLATION_MODE mode) = 0;
//! Animates this mesh's joints based on frame input
virtual void animateMesh(f32 frame, f32 blend) = 0;
//! Preforms a software skin on this mesh based of joint positions
virtual void skinMesh() = 0;
//! converts the vertex type of all meshbuffers to tangents.
/** E.g. used for bump mapping. */
virtual void convertMeshToTangents() = 0;
//! Allows to enable hardware skinning.
/* This feature is not implemented in Irrlicht yet */
virtual bool setHardwareSkinning(bool on) = 0;
//! Refreshes vertex data cached in joints such as positions and normals
virtual void refreshJointCache() = 0;
//! Moves the mesh into static position.
virtual void resetAnimation() = 0;
//! A vertex weight
struct SWeight
{
//! Index of the mesh buffer
u16 buffer_id; // I doubt 32bits is needed
//! Index of the vertex
u32 vertex_id; // Store global ID here
//! Weight Strength/Percentage (0-1)
f32 strength;
private:
//! Internal members used by CSkinnedMesh
friend class CSkinnedMesh;
char *Moved;
core::vector3df StaticPos;
core::vector3df StaticNormal;
};
//! Animation keyframe which describes a new position
struct SPositionKey
{
f32 frame;
core::vector3df position;
};
//! Animation keyframe which describes a new scale
struct SScaleKey
{
f32 frame;
core::vector3df scale;
};
//! Animation keyframe which describes a new rotation
struct SRotationKey
{
f32 frame;
core::quaternion rotation;
};
//! Joints
struct SJoint
{
SJoint() :
UseAnimationFrom(0), GlobalSkinningSpace(false),
positionHint(-1), scaleHint(-1), rotationHint(-1)
{
}
//! The name of this joint
std::optional<std::string> Name;
//! Local matrix of this joint
core::matrix4 LocalMatrix;
//! List of child joints
core::array<SJoint *> Children;
//! List of attached meshes
core::array<u32> AttachedMeshes;
//! Animation keys causing translation change
core::array<SPositionKey> PositionKeys;
//! Animation keys causing scale change
core::array<SScaleKey> ScaleKeys;
//! Animation keys causing rotation change
core::array<SRotationKey> RotationKeys;
//! Skin weights
core::array<SWeight> Weights;
//! Unnecessary for loaders, will be overwritten on finalize
core::matrix4 GlobalMatrix;
core::matrix4 GlobalAnimatedMatrix;
core::matrix4 LocalAnimatedMatrix;
core::vector3df Animatedposition;
core::vector3df Animatedscale;
core::quaternion Animatedrotation;
core::matrix4 GlobalInversedMatrix; // the x format pre-calculates this
private:
//! Internal members used by CSkinnedMesh
friend class CSkinnedMesh;
SJoint *UseAnimationFrom;
bool GlobalSkinningSpace;
s32 positionHint;
s32 scaleHint;
s32 rotationHint;
};
// Interface for the mesh loaders (finalize should lock these functions, and they should have some prefix like loader_
// these functions will use the needed arrays, set values, etc to help the loaders
//! exposed for loaders: to add mesh buffers
virtual core::array<SSkinMeshBuffer *> &getMeshBuffers() = 0;
//! exposed for loaders: joints list
virtual core::array<SJoint *> &getAllJoints() = 0;
//! exposed for loaders: joints list
virtual const core::array<SJoint *> &getAllJoints() const = 0;
//! loaders should call this after populating the mesh
virtual void finalize() = 0;
//! Adds a new meshbuffer to the mesh, access it as last one
virtual SSkinMeshBuffer *addMeshBuffer() = 0;
//! Adds a new joint to the mesh, access it as last one
virtual SJoint *addJoint(SJoint *parent = 0) = 0;
//! Adds a new weight to the mesh, access it as last one
virtual SWeight *addWeight(SJoint *joint) = 0;
//! Adds a new position key to the mesh, access it as last one
virtual SPositionKey *addPositionKey(SJoint *joint) = 0;
//! Adds a new scale key to the mesh, access it as last one
virtual SScaleKey *addScaleKey(SJoint *joint) = 0;
//! Adds a new rotation key to the mesh, access it as last one
virtual SRotationKey *addRotationKey(SJoint *joint) = 0;
//! Check if the mesh is non-animated
virtual bool isStatic() = 0;
};
} // end namespace scene
} // end namespace irr

337
irr/include/ITexture.h Normal file
View File

@ -0,0 +1,337 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "IImage.h"
#include "dimension2d.h"
#include "EDriverTypes.h"
#include "path.h"
#include "matrix4.h"
namespace irr
{
namespace video
{
//! Enumeration flags used to tell the video driver with setTextureCreationFlag in which format textures should be created.
enum E_TEXTURE_CREATION_FLAG
{
/** Forces the driver to create 16 bit textures always, independent of
which format the file on disk has. When choosing this you may lose
some color detail, but gain much speed and memory. 16 bit textures can
be transferred twice as fast as 32 bit textures and only use half of
the space in memory.
When using this flag, it does not make sense to use the flags
ETCF_ALWAYS_32_BIT, ETCF_OPTIMIZED_FOR_QUALITY, or
ETCF_OPTIMIZED_FOR_SPEED at the same time.
Not all texture formats are affected (usually those up to ECF_A8R8G8B8). */
ETCF_ALWAYS_16_BIT = 0x00000001,
/** Forces the driver to create 32 bit textures always, independent of
which format the file on disk has. Please note that some drivers (like
the software device) will ignore this, because they are only able to
create and use 16 bit textures.
Default is true.
When using this flag, it does not make sense to use the flags
ETCF_ALWAYS_16_BIT, ETCF_OPTIMIZED_FOR_QUALITY, or
ETCF_OPTIMIZED_FOR_SPEED at the same time.
Not all texture formats are affected (usually those up to ECF_A8R8G8B8). */
ETCF_ALWAYS_32_BIT = 0x00000002,
/** Lets the driver decide in which format the textures are created and
tries to make the textures look as good as possible. Usually it simply
chooses the format in which the texture was stored on disk.
When using this flag, it does not make sense to use the flags
ETCF_ALWAYS_16_BIT, ETCF_ALWAYS_32_BIT, or ETCF_OPTIMIZED_FOR_SPEED at
the same time.
Not all texture formats are affected (usually those up to ECF_A8R8G8B8). */
ETCF_OPTIMIZED_FOR_QUALITY = 0x00000004,
/** Lets the driver decide in which format the textures are created and
tries to create them maximizing render speed.
When using this flag, it does not make sense to use the flags
ETCF_ALWAYS_16_BIT, ETCF_ALWAYS_32_BIT, or ETCF_OPTIMIZED_FOR_QUALITY,
at the same time.
Not all texture formats are affected (usually those up to ECF_A8R8G8B8). */
ETCF_OPTIMIZED_FOR_SPEED = 0x00000008,
/** Creates textures with mipmap levels.
If disabled textures can not have mipmaps.
Default is true. */
ETCF_CREATE_MIP_MAPS = 0x00000010,
/** Discard any alpha layer and use non-alpha color format.
Warning: This may lead to getting 24-bit texture formats which
are often badly supported by drivers. So it's generally
not recommended to enable this flag. */
ETCF_NO_ALPHA_CHANNEL = 0x00000020,
//! Allow the Driver to use Non-Power-2-Textures
/** BurningVideo can handle Non-Power-2 Textures in 2D (GUI), but not in 3D. */
ETCF_ALLOW_NON_POWER_2 = 0x00000040,
//! Allow the driver to keep a copy of the texture in memory
/** Enabling this makes calls to ITexture::lock a lot faster, but costs main memory.
Currently only used in combination with OpenGL drivers.
NOTE: Disabling this does not yet work correctly with alpha-textures.
So the default is on for now (but might change with Irrlicht 1.9 if we get the alpha-troubles fixed).
*/
ETCF_ALLOW_MEMORY_COPY = 0x00000080,
//! Enable automatic updating mip maps when the base texture changes.
/** Default is true.
This flag is only used when ETCF_CREATE_MIP_MAPS is also enabled and if the driver supports it.
Please note:
- On D3D (and maybe older OGL?) you can no longer manually set mipmap data when enabled
(for example mips from image loading will be ignored).
- On D3D (and maybe older OGL?) texture locking for mipmap levels usually won't work anymore.
- On new OGL this flag is ignored.
- When disabled you do _not_ get hardware mipmaps on D3D, so mipmap generation can be slower.
- When disabled you can still update your mipmaps when the texture changed by manually calling regenerateMipMapLevels.
- You can still call regenerateMipMapLevels when this flag is enabled (it will be a hint on d3d to update mips immediately)
*/
ETCF_AUTO_GENERATE_MIP_MAPS = 0x00000100,
/** This flag is never used, it only forces the compiler to compile
these enumeration values to 32 bit. */
ETCF_FORCE_32_BIT_DO_NOT_USE = 0x7fffffff
};
//! Enum for the mode for texture locking. Read-Only, write-only or read/write.
enum E_TEXTURE_LOCK_MODE
{
//! The default mode. Texture can be read and written to.
ETLM_READ_WRITE = 0,
//! Read only. The texture is downloaded, but not uploaded again.
/** Often used to read back shader generated textures. */
ETLM_READ_ONLY,
//! Write only. The texture is not downloaded and might be uninitialized.
/** The updated texture is uploaded to the GPU.
Used for initializing the shader from the CPU. */
ETLM_WRITE_ONLY
};
//! Additional bitflags for ITexture::lock() call
enum E_TEXTURE_LOCK_FLAGS
{
ETLF_NONE = 0,
//! Flip left-bottom origin rendertarget textures upside-down
/** Irrlicht usually has all textures with left-top as origin.
And for drivers with a left-bottom origin coordinate system (OpenGL)
Irrlicht modifies the texture-matrix in the fixed function pipeline to make
the textures show up correctly (shader coders have to handle upside down
textures themselves).
But rendertarget textures (RTT's) are written by drivers the way the
coordinate system of that driver works. So on OpenGL images tend to look
upside down (aka Y coordinate going up) on lock() when this flag isn't set.
When the flag is set it will flip such textures on lock() to make them look
like non-rtt textures (origin left-top). Note that this also means the texture
will be uploaded flipped on unlock. So mostly you want to have this flag set
when you want to look at the texture or save it, but unset if you want to
upload it again to the card.
If you disable this flag you get the memory just as it is on the graphic card.
For backward compatibility reasons this flag is enabled by default. */
ETLF_FLIP_Y_UP_RTT = 1
};
//! Where did the last IVideoDriver::getTexture call find this texture
enum E_TEXTURE_SOURCE
{
//! IVideoDriver::getTexture was never called (texture created otherwise)
ETS_UNKNOWN,
//! Texture has been found in cache
ETS_FROM_CACHE,
//! Texture had to be loaded
ETS_FROM_FILE
};
//! Enumeration describing the type of ITexture.
enum E_TEXTURE_TYPE
{
//! 2D texture.
ETT_2D,
//! Cubemap texture.
ETT_CUBEMAP
};
//! Interface of a Video Driver dependent Texture.
/** An ITexture is created by an IVideoDriver by using IVideoDriver::addTexture
or IVideoDriver::getTexture. After that, the texture may only be used by this
VideoDriver. As you can imagine, textures of the DirectX and the OpenGL device
will, e.g., not be compatible. An exception is the Software device and the
NULL device, their textures are compatible. If you try to use a texture
created by one device with an other device, the device will refuse to do that
and write a warning or an error message to the output buffer.
*/
class ITexture : public virtual IReferenceCounted
{
public:
//! constructor
ITexture(const io::path &name, E_TEXTURE_TYPE type) :
NamedPath(name), DriverType(EDT_NULL), OriginalColorFormat(ECF_UNKNOWN),
ColorFormat(ECF_UNKNOWN), Pitch(0), HasMipMaps(false), IsRenderTarget(false), Source(ETS_UNKNOWN), Type(type)
{
}
//! Lock function.
/** Locks the Texture and returns a pointer to access the
pixels. After lock() has been called and all operations on the pixels
are done, you must call unlock().
Locks are not accumulating, hence one unlock will do for an arbitrary
number of previous locks. You should avoid locking different levels without
unlocking in between, though, because only the last level locked will be
unlocked.
The size of the i-th mipmap level is defined as max(getSize().Width>>i,1)
and max(getSize().Height>>i,1)
\param mode Specifies what kind of changes to the locked texture are
allowed. Unspecified behavior will arise if texture is written in read
only mode or read from in write only mode.
Support for this feature depends on the driver, so don't rely on the
texture being write-protected when locking with read-only, etc.
\param mipmapLevel NOTE: Currently broken, sorry, we try if we can repair it for 1.9 release.
Number of the mipmapLevel to lock. 0 is main texture.
Non-existing levels will silently fail and return 0.
\param layer It determines which cubemap face or texture array layer should be locked.
\param lockFlags See E_TEXTURE_LOCK_FLAGS documentation.
\return Returns a pointer to the pixel data. The format of the pixel can
be determined by using getColorFormat(). 0 is returned, if
the texture cannot be locked. */
virtual void *lock(E_TEXTURE_LOCK_MODE mode = ETLM_READ_WRITE, u32 mipmapLevel = 0, u32 layer = 0, E_TEXTURE_LOCK_FLAGS lockFlags = ETLF_FLIP_Y_UP_RTT) = 0;
//! Unlock function. Must be called after a lock() to the texture.
/** One should avoid to call unlock more than once before another lock.
The last locked mip level will be unlocked.
You may want to call regenerateMipMapLevels() after this when you changed any data. */
virtual void unlock() = 0;
//! Regenerates the mip map levels of the texture.
/** Required after modifying the texture, usually after calling unlock().
\param data Optional parameter to pass in image data which will be
used instead of the previously stored or automatically generated mipmap
data. The data has to be a continuous pixel data for all mipmaps until
1x1 pixel. Each mipmap has to be half the width and height of the previous
level. At least one pixel will be always kept.
\param layer It informs a texture about which cubemap or texture array layer
needs mipmap regeneration. */
virtual void regenerateMipMapLevels(void *data = 0, u32 layer = 0) = 0;
//! Get original size of the texture.
/** The texture is usually scaled, if it was created with an unoptimal
size. For example if the size was not a power of two. This method
returns the size of the texture it had before it was scaled. Can be
useful when drawing 2d images on the screen, which should have the
exact size of the original texture. Use ITexture::getSize() if you want
to know the real size it has now stored in the system.
\return The original size of the texture. */
const core::dimension2d<u32> &getOriginalSize() const { return OriginalSize; };
//! Get dimension (=size) of the texture.
/** \return The size of the texture. */
const core::dimension2d<u32> &getSize() const { return Size; };
//! Get driver type of texture.
/** This is the driver, which created the texture. This method is used
internally by the video devices, to check, if they may use a texture
because textures may be incompatible between different devices.
\return Driver type of texture. */
E_DRIVER_TYPE getDriverType() const { return DriverType; };
//! Get the color format of texture.
/** \return The color format of texture. */
ECOLOR_FORMAT getColorFormat() const { return ColorFormat; };
//! Get the original color format
/** When create textures from image data we will often use different color formats.
For example depending on driver TextureCreationFlag's.
This can give you the original format which the image used to create the texture had */
ECOLOR_FORMAT getOriginalColorFormat() const { return OriginalColorFormat; };
//! Get pitch of the main texture (in bytes).
/** The pitch is the amount of bytes used for a row of pixels in a
texture.
\return Pitch of texture in bytes. */
u32 getPitch() const { return Pitch; };
//! Check whether the texture has MipMaps
/** \return True if texture has MipMaps, else false. */
bool hasMipMaps() const { return HasMipMaps; }
//! Check whether the texture is a render target
/** Render targets can be set as such in the video driver, in order to
render a scene into the texture. Once unbound as render target, they can
be used just as usual textures again.
\return True if this is a render target, otherwise false. */
bool isRenderTarget() const { return IsRenderTarget; }
//! Get name of texture (in most cases this is the filename)
const io::SNamedPath &getName() const { return NamedPath; }
//! Check where the last IVideoDriver::getTexture found this texture
E_TEXTURE_SOURCE getSource() const { return Source; }
//! Used internally by the engine to update Source status on IVideoDriver::getTexture calls.
void updateSource(E_TEXTURE_SOURCE source) { Source = source; }
//! Returns if the texture has an alpha channel
bool hasAlpha() const
{
bool status = false;
switch (ColorFormat) {
case ECF_A8R8G8B8:
case ECF_A1R5G5B5:
case ECF_A16B16G16R16F:
case ECF_A32B32G32R32F:
status = true;
break;
default:
break;
}
return status;
}
//! Returns the type of texture
E_TEXTURE_TYPE getType() const { return Type; }
protected:
//! Helper function, helps to get the desired texture creation format from the flags.
/** \return Either ETCF_ALWAYS_32_BIT, ETCF_ALWAYS_16_BIT,
ETCF_OPTIMIZED_FOR_QUALITY, or ETCF_OPTIMIZED_FOR_SPEED. */
inline E_TEXTURE_CREATION_FLAG getTextureFormatFromFlags(u32 flags)
{
if (flags & ETCF_OPTIMIZED_FOR_SPEED)
return ETCF_OPTIMIZED_FOR_SPEED;
if (flags & ETCF_ALWAYS_16_BIT)
return ETCF_ALWAYS_16_BIT;
if (flags & ETCF_ALWAYS_32_BIT)
return ETCF_ALWAYS_32_BIT;
if (flags & ETCF_OPTIMIZED_FOR_QUALITY)
return ETCF_OPTIMIZED_FOR_QUALITY;
return ETCF_OPTIMIZED_FOR_SPEED;
}
io::SNamedPath NamedPath;
core::dimension2d<u32> OriginalSize;
core::dimension2d<u32> Size;
E_DRIVER_TYPE DriverType;
ECOLOR_FORMAT OriginalColorFormat;
ECOLOR_FORMAT ColorFormat;
u32 Pitch;
bool HasMipMaps;
bool IsRenderTarget;
E_TEXTURE_SOURCE Source;
E_TEXTURE_TYPE Type;
};
} // end namespace video
} // end namespace irr

65
irr/include/ITimer.h Normal file
View File

@ -0,0 +1,65 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
namespace irr
{
//! Interface for getting and manipulating the virtual time
class ITimer : public virtual IReferenceCounted
{
public:
//! Returns current real time in milliseconds of the system.
/** This value does not start with 0 when the application starts.
For example in one implementation the value returned could be the
amount of milliseconds which have elapsed since the system was started.
*/
virtual u32 getRealTime() const = 0;
//! Returns current virtual time in milliseconds.
/** This value starts with 0 and can be manipulated using setTime(),
stopTimer(), startTimer(), etc. This value depends on the set speed of
the timer if the timer is stopped, etc. If you need the system time,
use getRealTime() */
virtual u32 getTime() const = 0;
//! sets current virtual time
virtual void setTime(u32 time) = 0;
//! Stops the virtual timer.
/** The timer is reference counted, which means everything which calls
stop() will also have to call start(), otherwise the timer may not
start/stop correctly again. */
virtual void stop() = 0;
//! Starts the virtual timer.
/** The timer is reference counted, which means everything which calls
stop() will also have to call start(), otherwise the timer may not
start/stop correctly again. */
virtual void start() = 0;
//! Sets the speed of the timer
/** The speed is the factor with which the time is running faster or
slower then the real system time. */
virtual void setSpeed(f32 speed = 1.0f) = 0;
//! Returns current speed of the timer
/** The speed is the factor with which the time is running faster or
slower then the real system time. */
virtual f32 getSpeed() const = 0;
//! Returns if the virtual timer is currently stopped
virtual bool isStopped() const = 0;
//! Advances the virtual time
/** Makes the virtual timer update the time value based on the real
time. This is called automatically when calling IrrlichtDevice::run(),
but you can call it manually if you don't use this method. */
virtual void tick() = 0;
};
} // end namespace irr

48
irr/include/IVertexBuffer.h Normal file
View File

@ -0,0 +1,48 @@
// Copyright (C) 2008-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "irrArray.h"
#include "EHardwareBufferFlags.h"
#include "S3DVertex.h"
namespace irr
{
namespace scene
{
class IVertexBuffer : public virtual IReferenceCounted
{
public:
virtual void *getData() = 0;
virtual video::E_VERTEX_TYPE getType() const = 0;
virtual void setType(video::E_VERTEX_TYPE vertexType) = 0;
virtual u32 stride() const = 0;
virtual u32 size() const = 0;
virtual void push_back(const video::S3DVertex &element) = 0;
virtual video::S3DVertex &operator[](const u32 index) const = 0;
virtual video::S3DVertex &getLast() = 0;
virtual void set_used(u32 usedNow) = 0;
virtual void reallocate(u32 new_size) = 0;
virtual u32 allocated_size() const = 0;
virtual video::S3DVertex *pointer() = 0;
//! get the current hardware mapping hint
virtual E_HARDWARE_MAPPING getHardwareMappingHint() const = 0;
//! set the hardware mapping hint, for driver
virtual void setHardwareMappingHint(E_HARDWARE_MAPPING NewMappingHint) = 0;
//! flags the meshbuffer as changed, reloads hardware buffers
virtual void setDirty() = 0;
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
virtual u32 getChangedID() const = 0;
};
} // end namespace scene
} // end namespace irr

1207
irr/include/IVideoDriver.h Normal file
View File

File diff suppressed because it is too large Load Diff

47
irr/include/IWriteFile.h Normal file
View File

@ -0,0 +1,47 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "path.h"
namespace irr
{
namespace io
{
//! Interface providing write access to a file.
class IWriteFile : public virtual IReferenceCounted
{
public:
//! Writes an amount of bytes to the file.
/** \param buffer Pointer to buffer of bytes to write.
\param sizeToWrite Amount of bytes to write to the file.
\return How much bytes were written. */
virtual size_t write(const void *buffer, size_t sizeToWrite) = 0;
//! Changes position in file
/** \param finalPos Destination position in the file.
\param relativeMovement If set to true, the position in the file is
changed relative to current position. Otherwise the position is changed
from begin of file.
\return True if successful, otherwise false. */
virtual bool seek(long finalPos, bool relativeMovement = false) = 0;
//! Get the current position in the file.
/** \return Current position in the file in bytes on success or -1L on failure */
virtual long getPos() const = 0;
//! Get name of file.
/** \return File name as zero terminated character string. */
virtual const path &getFileName() const = 0;
//! Flush the content of the buffer in the file
/** \return True if successful, otherwise false. */
virtual bool flush() = 0;
};
} // end namespace io
} // end namespace irr

28
irr/include/IrrCompileConfig.h Normal file
View File

@ -0,0 +1,28 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
//! Identifies the IrrlichtMt fork customized for the Minetest engine
#define IRRLICHT_VERSION_MT_REVISION 15
#define IRRLICHT_VERSION_MT "mt15"
//! Irrlicht SDK Version
#define IRRLICHT_VERSION_MAJOR 1
#define IRRLICHT_VERSION_MINOR 9
#define IRRLICHT_VERSION_REVISION 0
// This flag will be defined only in SVN, the official release code will have
// it undefined
#define IRRLICHT_VERSION_SVN alpha
#define IRRLICHT_SDK_VERSION "1.9.0" IRRLICHT_VERSION_MT
#ifdef _WIN32
#define IRRCALLCONV __stdcall
#else
#define IRRCALLCONV
#endif
#ifndef IRRLICHT_API
#define IRRLICHT_API
#endif

341
irr/include/IrrlichtDevice.h Normal file
View File

@ -0,0 +1,341 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IReferenceCounted.h"
#include "dimension2d.h"
#include "IVideoDriver.h"
#include "EDriverTypes.h"
#include "EDeviceTypes.h"
#include "IEventReceiver.h"
#include "ICursorControl.h"
#include "ITimer.h"
#include "IOSOperator.h"
#include "IrrCompileConfig.h"
namespace irr
{
class ILogger;
class IEventReceiver;
namespace io
{
class IFileSystem;
} // end namespace io
namespace gui
{
class IGUIEnvironment;
} // end namespace gui
namespace scene
{
class ISceneManager;
} // end namespace scene
namespace video
{
class IContextManager;
extern "C" IRRLICHT_API bool IRRCALLCONV isDriverSupported(E_DRIVER_TYPE driver);
} // end namespace video
//! The Irrlicht device. You can create it with createDevice() or createDeviceEx().
/** This is the most important class of the Irrlicht Engine. You can
access everything in the engine if you have a pointer to an instance of
this class. There should be only one instance of this class at any
time.
*/
class IrrlichtDevice : public virtual IReferenceCounted
{
public:
//! Runs the device.
/** Also increments the virtual timer by calling
ITimer::tick();. You can prevent this
by calling ITimer::stop(); before and ITimer::start() after
calling IrrlichtDevice::run(). Returns false if device wants
to be deleted. Use it in this way:
\code
while(device->run())
{
// draw everything here
}
\endcode
If you want the device to do nothing if the window is inactive
(recommended), use the slightly enhanced code shown at isWindowActive().
Note if you are running Irrlicht inside an external, custom
created window: Calling Device->run() will cause Irrlicht to
dispatch windows messages internally.
If you are running Irrlicht in your own custom window, you can
also simply use your own message loop using GetMessage,
DispatchMessage and whatever and simply don't use this method.
But note that Irrlicht will not be able to fetch user input
then. See irr::SIrrlichtCreationParameters::WindowId for more
information and example code.
*/
virtual bool run() = 0;
//! Cause the device to temporarily pause execution and let other processes run.
/** This should bring down processor usage without major performance loss for Irrlicht.
But this is system dependent, so there's a chance your thread won't get control back quickly.
*/
virtual void yield() = 0;
//! Pause execution and let other processes to run for a specified amount of time.
/** It may not wait the full given time, as sleep may be interrupted and also may wait longer on some OS.
\param timeMs: Time to sleep for in milliseconds. Note that the OS can round up this number.
On Windows you usually get at least 15ms sleep time minium for any value > 0.
So if you call this in your main loop you can't get more than 65 FPS anymore in your game.
On most Linux systems it's relatively exact, but also no guarantee.
\param pauseTimer: If true, pauses the device timer while sleeping
*/
virtual void sleep(u32 timeMs, bool pauseTimer = false) = 0;
//! Provides access to the video driver for drawing 3d and 2d geometry.
/** \return Pointer the video driver. */
virtual video::IVideoDriver *getVideoDriver() = 0;
//! Provides access to the virtual file system.
/** \return Pointer to the file system. */
virtual io::IFileSystem *getFileSystem() = 0;
//! Provides access to the 2d user interface environment.
/** \return Pointer to the gui environment. */
virtual gui::IGUIEnvironment *getGUIEnvironment() = 0;
//! Provides access to the scene manager.
/** \return Pointer to the scene manager. */
virtual scene::ISceneManager *getSceneManager() = 0;
//! Provides access to the cursor control.
/** \return Pointer to the mouse cursor control interface. */
virtual gui::ICursorControl *getCursorControl() = 0;
//! Provides access to the message logger.
/** \return Pointer to the logger. */
virtual ILogger *getLogger() = 0;
//! Get context manager
virtual video::IContextManager *getContextManager() = 0;
//! Provides access to the operation system operator object.
/** The OS operator provides methods for
getting system specific information and doing system
specific operations, such as exchanging data with the clipboard
or reading the operation system version.
\return Pointer to the OS operator. */
virtual IOSOperator *getOSOperator() = 0;
//! Provides access to the engine's timer.
/** The system time can be retrieved by it as
well as the virtual time, which also can be manipulated.
\return Pointer to the ITimer object. */
virtual ITimer *getTimer() = 0;
//! Sets the caption of the window.
/** \param text: New text of the window caption. */
virtual void setWindowCaption(const wchar_t *text) = 0;
//! Sets the window icon.
/** \param img The icon texture.
\return False if no icon was set. */
virtual bool setWindowIcon(const video::IImage *img) = 0;
//! Returns if the window is active.
/** If the window is inactive,
nothing needs to be drawn. So if you don't want to draw anything
when the window is inactive, create your drawing loop this way:
\code
while(device->run())
{
if (device->isWindowActive())
{
// draw everything here
}
else
device->yield();
}
\endcode
\return True if window is active. */
virtual bool isWindowActive() const = 0;
//! Checks if the Irrlicht window has the input focus
/** \return True if window has focus. */
virtual bool isWindowFocused() const = 0;
//! Checks if the Irrlicht window is minimized
/** \return True if window is minimized. */
virtual bool isWindowMinimized() const = 0;
//! Checks if the Irrlicht window is maximized
//! Only fully works on SDL. Returns false, or the last value set via
//! maximizeWindow() and restoreWindow(), on other backends.
/** \return True if window is maximized. */
virtual bool isWindowMaximized() const = 0;
//! Checks if the Irrlicht window is running in fullscreen mode
/** \return True if window is fullscreen. */
virtual bool isFullscreen() const = 0;
//! Checks if the window could possibly be visible.
//! Currently, this only returns false when the activity is stopped on
//! Android. Note that for Android activities, "stopped" means something
//! different than you might expect (and also something different than
//! "paused"). Read the Android lifecycle documentation.
virtual bool isWindowVisible() const { return true; };
//! Get the current color format of the window
/** \return Color format of the window. */
virtual video::ECOLOR_FORMAT getColorFormat() const = 0;
//! Notifies the device that it should close itself.
/** IrrlichtDevice::run() will always return false after closeDevice() was called. */
virtual void closeDevice() = 0;
//! Get the version of the engine.
/** The returned string
will look like this: "1.2.3" or this: "1.2".
\return String which contains the version. */
virtual const c8 *getVersion() const = 0;
//! Sets a new user event receiver which will receive events from the engine.
/** Return true in IEventReceiver::OnEvent to prevent the event from continuing along
the chain of event receivers. The path that an event takes through the system depends
on its type. See irr::EEVENT_TYPE for details.
\param receiver New receiver to be used. */
virtual void setEventReceiver(IEventReceiver *receiver) = 0;
//! Provides access to the current event receiver.
/** \return Pointer to the current event receiver. Returns 0 if there is none. */
virtual IEventReceiver *getEventReceiver() = 0;
//! Sends a user created event to the engine.
/** Is is usually not necessary to use this. However, if you
are using an own input library for example for doing joystick
input, you can use this to post key or mouse input events to
the engine. Internally, this method only delegates the events
further to the scene manager and the GUI environment. */
virtual bool postEventFromUser(const SEvent &event) = 0;
//! Sets the input receiving scene manager.
/** If set to null, the main scene manager (returned by
GetSceneManager()) will receive the input
\param sceneManager New scene manager to be used. */
virtual void setInputReceivingSceneManager(scene::ISceneManager *sceneManager) = 0;
//! Sets if the window should be resizable in windowed mode.
/** The default is false. This method only works in windowed
mode.
\param resize Flag whether the window should be resizable. */
virtual void setResizable(bool resize = false) = 0;
//! Resize the render window.
/** This will only work in windowed mode and is not yet supported on all systems.
It does set the drawing/clientDC size of the window, the window decorations are added to that.
You get the current window size with IVideoDriver::getScreenSize() (might be unified in future)
*/
virtual void setWindowSize(const irr::core::dimension2d<u32> &size) = 0;
//! Minimizes the window if possible.
virtual void minimizeWindow() = 0;
//! Maximizes the window if possible.
virtual void maximizeWindow() = 0;
//! Restore the window to normal size if possible.
virtual void restoreWindow() = 0;
//! Get the position of the frame on-screen
virtual core::position2di getWindowPosition() = 0;
//! Activate any joysticks, and generate events for them.
/** Irrlicht contains support for joysticks, but does not generate joystick events by default,
as this would consume joystick info that 3rd party libraries might rely on. Call this method to
activate joystick support in Irrlicht and to receive irr::SJoystickEvent events.
\param joystickInfo On return, this will contain an array of each joystick that was found and activated.
\return true if joysticks are supported on this device, false if joysticks are not
supported or support is compiled out.
*/
virtual bool activateJoysticks(core::array<SJoystickInfo> &joystickInfo) = 0;
//! Activate accelerometer.
virtual bool activateAccelerometer(float updateInterval = 0.016666f) = 0;
//! Deactivate accelerometer.
virtual bool deactivateAccelerometer() = 0;
//! Is accelerometer active.
virtual bool isAccelerometerActive() = 0;
//! Is accelerometer available.
virtual bool isAccelerometerAvailable() = 0;
//! Activate gyroscope.
virtual bool activateGyroscope(float updateInterval = 0.016666f) = 0;
//! Deactivate gyroscope.
virtual bool deactivateGyroscope() = 0;
//! Is gyroscope active.
virtual bool isGyroscopeActive() = 0;
//! Is gyroscope available.
virtual bool isGyroscopeAvailable() = 0;
//! Activate device motion.
virtual bool activateDeviceMotion(float updateInterval = 0.016666f) = 0;
//! Deactivate device motion.
virtual bool deactivateDeviceMotion() = 0;
//! Is device motion active.
virtual bool isDeviceMotionActive() = 0;
//! Is device motion available.
virtual bool isDeviceMotionAvailable() = 0;
//! Set the maximal elapsed time between 2 clicks to generate doubleclicks for the mouse. It also affects tripleclick behavior.
/** When set to 0 no double- and tripleclicks will be generated.
\param timeMs maximal time in milliseconds for two consecutive clicks to be recognized as double click
*/
virtual void setDoubleClickTime(u32 timeMs) = 0;
//! Get the maximal elapsed time between 2 clicks to generate double- and tripleclicks for the mouse.
/** When return value is 0 no double- and tripleclicks will be generated.
\return maximal time in milliseconds for two consecutive clicks to be recognized as double click
*/
virtual u32 getDoubleClickTime() const = 0;
//! Remove messages pending in the system message loop
/** This function is usually used after messages have been buffered for a longer time, for example
when loading a large scene. Clearing the message loop prevents that mouse- or buttonclicks which users
have pressed in the meantime will now trigger unexpected actions in the gui. <br>
So far the following messages are cleared:<br>
Win32: All keyboard and mouse messages<br>
Linux: All keyboard and mouse messages<br>
All other devices are not yet supported here.<br>
The function is still somewhat experimental, as the kind of messages we clear is based on just a few use-cases.
If you think further messages should be cleared, or some messages should not be cleared here, then please tell us. */
virtual void clearSystemMessages() = 0;
//! Get the type of the device.
/** This allows the user to check which windowing system is currently being
used. */
virtual E_DEVICE_TYPE getType() const = 0;
//! Get the display density in dots per inch.
//! Returns 0.0f on failure.
virtual float getDisplayDensity() const = 0;
//! Check if a driver type is supported by the engine.
/** Even if true is returned the driver may not be available
for a configuration requested when creating the device. */
static bool isDriverSupported(video::E_DRIVER_TYPE driver)
{
return video::isDriverSupported(driver);
}
};
} // end namespace irr

185
irr/include/Keycodes.h Normal file
View File

@ -0,0 +1,185 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
namespace irr
{
enum EKEY_CODE
{
KEY_UNKNOWN = 0x0,
KEY_LBUTTON = 0x01, // Left mouse button
KEY_RBUTTON = 0x02, // Right mouse button
KEY_CANCEL = 0x03, // Control-break processing
KEY_MBUTTON = 0x04, // Middle mouse button (three-button mouse)
KEY_XBUTTON1 = 0x05, // Windows 2000/XP: X1 mouse button
KEY_XBUTTON2 = 0x06, // Windows 2000/XP: X2 mouse button
KEY_BACK = 0x08, // BACKSPACE key
KEY_TAB = 0x09, // TAB key
KEY_CLEAR = 0x0C, // CLEAR key
KEY_RETURN = 0x0D, // ENTER key
KEY_SHIFT = 0x10, // SHIFT key
KEY_CONTROL = 0x11, // CTRL key
KEY_MENU = 0x12, // ALT key
KEY_PAUSE = 0x13, // PAUSE key
KEY_CAPITAL = 0x14, // CAPS LOCK key
KEY_KANA = 0x15, // IME Kana mode
KEY_HANGUEL = 0x15, // IME Hanguel mode (maintained for compatibility use KEY_HANGUL)
KEY_HANGUL = 0x15, // IME Hangul mode
KEY_JUNJA = 0x17, // IME Junja mode
KEY_FINAL = 0x18, // IME final mode
KEY_HANJA = 0x19, // IME Hanja mode
KEY_KANJI = 0x19, // IME Kanji mode
KEY_ESCAPE = 0x1B, // ESC key
KEY_CONVERT = 0x1C, // IME convert
KEY_NONCONVERT = 0x1D, // IME nonconvert
KEY_ACCEPT = 0x1E, // IME accept
KEY_MODECHANGE = 0x1F, // IME mode change request
KEY_SPACE = 0x20, // SPACEBAR
KEY_PRIOR = 0x21, // PAGE UP key
KEY_NEXT = 0x22, // PAGE DOWN key
KEY_END = 0x23, // END key
KEY_HOME = 0x24, // HOME key
KEY_LEFT = 0x25, // LEFT ARROW key
KEY_UP = 0x26, // UP ARROW key
KEY_RIGHT = 0x27, // RIGHT ARROW key
KEY_DOWN = 0x28, // DOWN ARROW key
KEY_SELECT = 0x29, // SELECT key
KEY_PRINT = 0x2A, // PRINT key
KEY_EXECUT = 0x2B, // EXECUTE key
KEY_SNAPSHOT = 0x2C, // PRINT SCREEN key
KEY_INSERT = 0x2D, // INS key
KEY_DELETE = 0x2E, // DEL key
KEY_HELP = 0x2F, // HELP key
KEY_KEY_0 = 0x30, // 0 key
KEY_KEY_1 = 0x31, // 1 key
KEY_KEY_2 = 0x32, // 2 key
KEY_KEY_3 = 0x33, // 3 key
KEY_KEY_4 = 0x34, // 4 key
KEY_KEY_5 = 0x35, // 5 key
KEY_KEY_6 = 0x36, // 6 key
KEY_KEY_7 = 0x37, // 7 key
KEY_KEY_8 = 0x38, // 8 key
KEY_KEY_9 = 0x39, // 9 key
KEY_KEY_A = 0x41, // A key
KEY_KEY_B = 0x42, // B key
KEY_KEY_C = 0x43, // C key
KEY_KEY_D = 0x44, // D key
KEY_KEY_E = 0x45, // E key
KEY_KEY_F = 0x46, // F key
KEY_KEY_G = 0x47, // G key
KEY_KEY_H = 0x48, // H key
KEY_KEY_I = 0x49, // I key
KEY_KEY_J = 0x4A, // J key
KEY_KEY_K = 0x4B, // K key
KEY_KEY_L = 0x4C, // L key
KEY_KEY_M = 0x4D, // M key
KEY_KEY_N = 0x4E, // N key
KEY_KEY_O = 0x4F, // O key
KEY_KEY_P = 0x50, // P key
KEY_KEY_Q = 0x51, // Q key
KEY_KEY_R = 0x52, // R key
KEY_KEY_S = 0x53, // S key
KEY_KEY_T = 0x54, // T key
KEY_KEY_U = 0x55, // U key
KEY_KEY_V = 0x56, // V key
KEY_KEY_W = 0x57, // W key
KEY_KEY_X = 0x58, // X key
KEY_KEY_Y = 0x59, // Y key
KEY_KEY_Z = 0x5A, // Z key
KEY_LWIN = 0x5B, // Left Windows key (Microsoft Natural keyboard)
KEY_RWIN = 0x5C, // Right Windows key (Natural keyboard)
KEY_APPS = 0x5D, // Applications key (Natural keyboard)
KEY_SLEEP = 0x5F, // Computer Sleep key
KEY_NUMPAD0 = 0x60, // Numeric keypad 0 key
KEY_NUMPAD1 = 0x61, // Numeric keypad 1 key
KEY_NUMPAD2 = 0x62, // Numeric keypad 2 key
KEY_NUMPAD3 = 0x63, // Numeric keypad 3 key
KEY_NUMPAD4 = 0x64, // Numeric keypad 4 key
KEY_NUMPAD5 = 0x65, // Numeric keypad 5 key
KEY_NUMPAD6 = 0x66, // Numeric keypad 6 key
KEY_NUMPAD7 = 0x67, // Numeric keypad 7 key
KEY_NUMPAD8 = 0x68, // Numeric keypad 8 key
KEY_NUMPAD9 = 0x69, // Numeric keypad 9 key
KEY_MULTIPLY = 0x6A, // Multiply key
KEY_ADD = 0x6B, // Add key
KEY_SEPARATOR = 0x6C, // Separator key
KEY_SUBTRACT = 0x6D, // Subtract key
KEY_DECIMAL = 0x6E, // Decimal key
KEY_DIVIDE = 0x6F, // Divide key
KEY_F1 = 0x70, // F1 key
KEY_F2 = 0x71, // F2 key
KEY_F3 = 0x72, // F3 key
KEY_F4 = 0x73, // F4 key
KEY_F5 = 0x74, // F5 key
KEY_F6 = 0x75, // F6 key
KEY_F7 = 0x76, // F7 key
KEY_F8 = 0x77, // F8 key
KEY_F9 = 0x78, // F9 key
KEY_F10 = 0x79, // F10 key
KEY_F11 = 0x7A, // F11 key
KEY_F12 = 0x7B, // F12 key
KEY_F13 = 0x7C, // F13 key
KEY_F14 = 0x7D, // F14 key
KEY_F15 = 0x7E, // F15 key
KEY_F16 = 0x7F, // F16 key
KEY_F17 = 0x80, // F17 key
KEY_F18 = 0x81, // F18 key
KEY_F19 = 0x82, // F19 key
KEY_F20 = 0x83, // F20 key
KEY_F21 = 0x84, // F21 key
KEY_F22 = 0x85, // F22 key
KEY_F23 = 0x86, // F23 key
KEY_F24 = 0x87, // F24 key
KEY_NUMLOCK = 0x90, // NUM LOCK key
KEY_SCROLL = 0x91, // SCROLL LOCK key
KEY_LSHIFT = 0xA0, // Left SHIFT key
KEY_RSHIFT = 0xA1, // Right SHIFT key
KEY_LCONTROL = 0xA2, // Left CONTROL key
KEY_RCONTROL = 0xA3, // Right CONTROL key
KEY_LMENU = 0xA4, // Left MENU key
KEY_RMENU = 0xA5, // Right MENU key
KEY_BROWSER_BACK = 0xA6, // Browser Back key
KEY_BROWSER_FORWARD = 0xA7, // Browser Forward key
KEY_BROWSER_REFRESH = 0xA8, // Browser Refresh key
KEY_BROWSER_STOP = 0xA9, // Browser Stop key
KEY_BROWSER_SEARCH = 0xAA, // Browser Search key
KEY_BROWSER_FAVORITES = 0xAB, // Browser Favorites key
KEY_BROWSER_HOME = 0xAC, // Browser Start and Home key
KEY_VOLUME_MUTE = 0xAD, // Volume Mute key
KEY_VOLUME_DOWN = 0xAE, // Volume Down key
KEY_VOLUME_UP = 0xAF, // Volume Up key
KEY_MEDIA_NEXT_TRACK = 0xB0, // Next Track key
KEY_MEDIA_PREV_TRACK = 0xB1, // Previous Track key
KEY_MEDIA_STOP = 0xB2, // Stop Media key
KEY_MEDIA_PLAY_PAUSE = 0xB3, // Play/Pause Media key
KEY_OEM_1 = 0xBA, // for US ";:"
KEY_PLUS = 0xBB, // Plus Key "+"
KEY_COMMA = 0xBC, // Comma Key ","
KEY_MINUS = 0xBD, // Minus Key "-"
KEY_PERIOD = 0xBE, // Period Key "."
KEY_OEM_2 = 0xBF, // for US "/?"
KEY_OEM_3 = 0xC0, // for US "`~"
KEY_OEM_4 = 0xDB, // for US "[{"
KEY_OEM_5 = 0xDC, // for US "\|"
KEY_OEM_6 = 0xDD, // for US "]}"
KEY_OEM_7 = 0xDE, // for US "'""
KEY_OEM_8 = 0xDF, // None
KEY_OEM_AX = 0xE1, // for Japan "AX"
KEY_OEM_102 = 0xE2, // "<>" or "\|"
KEY_ATTN = 0xF6, // Attn key
KEY_CRSEL = 0xF7, // CrSel key
KEY_EXSEL = 0xF8, // ExSel key
KEY_EREOF = 0xF9, // Erase EOF key
KEY_PLAY = 0xFA, // Play key
KEY_ZOOM = 0xFB, // Zoom key
KEY_PA1 = 0xFD, // PA1 key
KEY_OEM_CLEAR = 0xFE, // Clear key
KEY_NONE = 0xFF, // usually no key mapping, but some laptops use it for fn key
KEY_KEY_CODES_COUNT = 0x100 // this is not a key, but the amount of keycodes there are.
};
} // end namespace irr

288
irr/include/S3DVertex.h Normal file
View File

@ -0,0 +1,288 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "vector3d.h"
#include "vector2d.h"
#include "SColor.h"
namespace irr
{
namespace video
{
//! Enumeration for all vertex types there are.
enum E_VERTEX_TYPE
{
//! Standard vertex type used by the Irrlicht engine, video::S3DVertex.
EVT_STANDARD = 0,
//! Vertex with two texture coordinates, video::S3DVertex2TCoords.
/** Usually used for geometry with lightmaps or other special materials. */
EVT_2TCOORDS,
//! Vertex with a tangent and binormal vector, video::S3DVertexTangents.
/** Usually used for tangent space normal mapping.
Usually tangent and binormal get send to shaders as texture coordinate sets 1 and 2.
*/
EVT_TANGENTS
};
//! Array holding the built in vertex type names
const char *const sBuiltInVertexTypeNames[] = {
"standard",
"2tcoords",
"tangents",
0,
};
//! standard vertex used by the Irrlicht engine.
struct S3DVertex
{
//! default constructor
constexpr S3DVertex() :
Color(0xffffffff) {}
//! constructor
constexpr S3DVertex(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv) :
Pos(x, y, z), Normal(nx, ny, nz), Color(c), TCoords(tu, tv) {}
//! constructor
constexpr S3DVertex(const core::vector3df &pos, const core::vector3df &normal,
SColor color, const core::vector2df &tcoords) :
Pos(pos),
Normal(normal), Color(color), TCoords(tcoords) {}
//! Position
core::vector3df Pos;
//! Normal vector
core::vector3df Normal;
//! Color
SColor Color;
//! Texture coordinates
core::vector2df TCoords;
constexpr bool operator==(const S3DVertex &other) const
{
return ((Pos == other.Pos) && (Normal == other.Normal) &&
(Color == other.Color) && (TCoords == other.TCoords));
}
constexpr bool operator!=(const S3DVertex &other) const
{
return ((Pos != other.Pos) || (Normal != other.Normal) ||
(Color != other.Color) || (TCoords != other.TCoords));
}
constexpr bool operator<(const S3DVertex &other) const
{
return ((Pos < other.Pos) ||
((Pos == other.Pos) && (Normal < other.Normal)) ||
((Pos == other.Pos) && (Normal == other.Normal) && (Color < other.Color)) ||
((Pos == other.Pos) && (Normal == other.Normal) && (Color == other.Color) && (TCoords < other.TCoords)));
}
//! Get type of the class
static E_VERTEX_TYPE getType()
{
return EVT_STANDARD;
}
//\param d d=0 returns other, d=1 returns this, values between interpolate.
S3DVertex getInterpolated(const S3DVertex &other, f32 d)
{
d = core::clamp(d, 0.0f, 1.0f);
return S3DVertex(Pos.getInterpolated(other.Pos, d),
Normal.getInterpolated(other.Normal, d),
Color.getInterpolated(other.Color, d),
TCoords.getInterpolated(other.TCoords, d));
}
};
//! Vertex with two texture coordinates.
/** Usually used for geometry with lightmaps
or other special materials.
*/
struct S3DVertex2TCoords : public S3DVertex
{
//! default constructor
constexpr S3DVertex2TCoords() :
S3DVertex() {}
//! constructor with two different texture coords, but no normal
constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2) :
S3DVertex(x, y, z, 0.0f, 0.0f, 0.0f, c, tu, tv), TCoords2(tu2, tv2) {}
//! constructor with two different texture coords, but no normal
constexpr S3DVertex2TCoords(const core::vector3df &pos, SColor color,
const core::vector2df &tcoords, const core::vector2df &tcoords2) :
S3DVertex(pos, core::vector3df(), color, tcoords),
TCoords2(tcoords2) {}
//! constructor with all values
constexpr S3DVertex2TCoords(const core::vector3df &pos, const core::vector3df &normal, const SColor &color,
const core::vector2df &tcoords, const core::vector2df &tcoords2) :
S3DVertex(pos, normal, color, tcoords),
TCoords2(tcoords2) {}
//! constructor with all values
constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz,
SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2) :
S3DVertex(x, y, z, nx, ny, nz, c, tu, tv),
TCoords2(tu2, tv2) {}
//! constructor with the same texture coords and normal
constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz,
SColor c, f32 tu, f32 tv) :
S3DVertex(x, y, z, nx, ny, nz, c, tu, tv),
TCoords2(tu, tv) {}
//! constructor with the same texture coords and normal
constexpr S3DVertex2TCoords(const core::vector3df &pos, const core::vector3df &normal,
SColor color, const core::vector2df &tcoords) :
S3DVertex(pos, normal, color, tcoords),
TCoords2(tcoords) {}
//! constructor from S3DVertex
constexpr S3DVertex2TCoords(const S3DVertex &o) :
S3DVertex(o) {}
//! Second set of texture coordinates
core::vector2df TCoords2;
//! Equality operator
constexpr bool operator==(const S3DVertex2TCoords &other) const
{
return ((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex &>(other)) &&
(TCoords2 == other.TCoords2));
}
//! Inequality operator
constexpr bool operator!=(const S3DVertex2TCoords &other) const
{
return ((static_cast<S3DVertex>(*this) != static_cast<const S3DVertex &>(other)) ||
(TCoords2 != other.TCoords2));
}
constexpr bool operator<(const S3DVertex2TCoords &other) const
{
return ((static_cast<S3DVertex>(*this) < other) ||
((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex &>(other)) && (TCoords2 < other.TCoords2)));
}
static E_VERTEX_TYPE getType()
{
return EVT_2TCOORDS;
}
//\param d d=0 returns other, d=1 returns this, values between interpolate.
S3DVertex2TCoords getInterpolated(const S3DVertex2TCoords &other, f32 d)
{
d = core::clamp(d, 0.0f, 1.0f);
return S3DVertex2TCoords(Pos.getInterpolated(other.Pos, d),
Normal.getInterpolated(other.Normal, d),
Color.getInterpolated(other.Color, d),
TCoords.getInterpolated(other.TCoords, d),
TCoords2.getInterpolated(other.TCoords2, d));
}
};
//! Vertex with a tangent and binormal vector.
/** Usually used for tangent space normal mapping.
Usually tangent and binormal get send to shaders as texture coordinate sets 1 and 2.
*/
struct S3DVertexTangents : public S3DVertex
{
//! default constructor
S3DVertexTangents() :
S3DVertex() {}
//! constructor
constexpr S3DVertexTangents(f32 x, f32 y, f32 z, f32 nx = 0.0f, f32 ny = 0.0f, f32 nz = 0.0f,
SColor c = 0xFFFFFFFF, f32 tu = 0.0f, f32 tv = 0.0f,
f32 tanx = 0.0f, f32 tany = 0.0f, f32 tanz = 0.0f,
f32 bx = 0.0f, f32 by = 0.0f, f32 bz = 0.0f) :
S3DVertex(x, y, z, nx, ny, nz, c, tu, tv),
Tangent(tanx, tany, tanz), Binormal(bx, by, bz) {}
//! constructor
constexpr S3DVertexTangents(const core::vector3df &pos, SColor c,
const core::vector2df &tcoords) :
S3DVertex(pos, core::vector3df(), c, tcoords) {}
//! constructor
constexpr S3DVertexTangents(const core::vector3df &pos,
const core::vector3df &normal, SColor c,
const core::vector2df &tcoords,
const core::vector3df &tangent = core::vector3df(),
const core::vector3df &binormal = core::vector3df()) :
S3DVertex(pos, normal, c, tcoords),
Tangent(tangent), Binormal(binormal) {}
//! constructor from S3DVertex
constexpr S3DVertexTangents(const S3DVertex &o) :
S3DVertex(o) {}
//! Tangent vector along the x-axis of the texture
core::vector3df Tangent;
//! Binormal vector (tangent x normal)
core::vector3df Binormal;
constexpr bool operator==(const S3DVertexTangents &other) const
{
return ((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex &>(other)) &&
(Tangent == other.Tangent) &&
(Binormal == other.Binormal));
}
constexpr bool operator!=(const S3DVertexTangents &other) const
{
return ((static_cast<S3DVertex>(*this) != static_cast<const S3DVertex &>(other)) ||
(Tangent != other.Tangent) ||
(Binormal != other.Binormal));
}
constexpr bool operator<(const S3DVertexTangents &other) const
{
return ((static_cast<S3DVertex>(*this) < other) ||
((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex &>(other)) && (Tangent < other.Tangent)) ||
((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex &>(other)) && (Tangent == other.Tangent) && (Binormal < other.Binormal)));
}
static E_VERTEX_TYPE getType()
{
return EVT_TANGENTS;
}
S3DVertexTangents getInterpolated(const S3DVertexTangents &other, f32 d)
{
d = core::clamp(d, 0.0f, 1.0f);
return S3DVertexTangents(Pos.getInterpolated(other.Pos, d),
Normal.getInterpolated(other.Normal, d),
Color.getInterpolated(other.Color, d),
TCoords.getInterpolated(other.TCoords, d),
Tangent.getInterpolated(other.Tangent, d),
Binormal.getInterpolated(other.Binormal, d));
}
};
inline u32 getVertexPitchFromType(E_VERTEX_TYPE vertexType)
{
switch (vertexType) {
case video::EVT_2TCOORDS:
return sizeof(video::S3DVertex2TCoords);
case video::EVT_TANGENTS:
return sizeof(video::S3DVertexTangents);
default:
return sizeof(video::S3DVertex);
}
}
} // end namespace video
} // end namespace irr

177
irr/include/SAnimatedMesh.h Normal file
View File

@ -0,0 +1,177 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "IAnimatedMesh.h"
#include "IMesh.h"
#include "aabbox3d.h"
#include "irrArray.h"
namespace irr
{
namespace scene
{
//! Simple implementation of the IAnimatedMesh interface.
struct SAnimatedMesh : public IAnimatedMesh
{
//! constructor
SAnimatedMesh(scene::IMesh *mesh = 0, scene::E_ANIMATED_MESH_TYPE type = scene::EAMT_UNKNOWN) :
IAnimatedMesh(), FramesPerSecond(25.f), Type(type)
{
#ifdef _DEBUG
setDebugName("SAnimatedMesh");
#endif
addMesh(mesh);
recalculateBoundingBox();
}
//! destructor
virtual ~SAnimatedMesh()
{
// drop meshes
for (u32 i = 0; i < Meshes.size(); ++i)
Meshes[i]->drop();
}
//! Gets the frame count of the animated mesh.
/** \return Amount of frames. If the amount is 1, it is a static, non animated mesh. */
u32 getFrameCount() const override
{
return Meshes.size();
}
//! Gets the default animation speed of the animated mesh.
/** \return Amount of frames per second. If the amount is 0, it is a static, non animated mesh. */
f32 getAnimationSpeed() const override
{
return FramesPerSecond;
}
//! Gets the frame count of the animated mesh.
/** \param fps Frames per second to play the animation with. If the amount is 0, it is not animated.
The actual speed is set in the scene node the mesh is instantiated in.*/
void setAnimationSpeed(f32 fps) override
{
FramesPerSecond = fps;
}
//! Returns the IMesh interface for a frame.
/** \param frame: Frame number as zero based index. The maximum frame number is
getFrameCount() - 1;
\param detailLevel: Level of detail. 0 is the lowest,
255 the highest level of detail. Most meshes will ignore the detail level.
\param startFrameLoop: start frame
\param endFrameLoop: end frame
\return The animated mesh based on a detail level. */
IMesh *getMesh(s32 frame, s32 detailLevel = 255, s32 startFrameLoop = -1, s32 endFrameLoop = -1) override
{
if (Meshes.empty())
return 0;
return Meshes[frame];
}
//! adds a Mesh
void addMesh(IMesh *mesh)
{
if (mesh) {
mesh->grab();
Meshes.push_back(mesh);
}
}
//! Returns an axis aligned bounding box of the mesh.
/** \return A bounding box of this mesh is returned. */
const core::aabbox3d<f32> &getBoundingBox() const override
{
return Box;
}
//! set user axis aligned bounding box
void setBoundingBox(const core::aabbox3df &box) override
{
Box = box;
}
//! Recalculates the bounding box.
void recalculateBoundingBox()
{
Box.reset(0, 0, 0);
if (Meshes.empty())
return;
Box = Meshes[0]->getBoundingBox();
for (u32 i = 1; i < Meshes.size(); ++i)
Box.addInternalBox(Meshes[i]->getBoundingBox());
}
//! Returns the type of the animated mesh.
E_ANIMATED_MESH_TYPE getMeshType() const override
{
return Type;
}
//! returns amount of mesh buffers.
u32 getMeshBufferCount() const override
{
if (Meshes.empty())
return 0;
return Meshes[0]->getMeshBufferCount();
}
//! returns pointer to a mesh buffer
IMeshBuffer *getMeshBuffer(u32 nr) const override
{
if (Meshes.empty())
return 0;
return Meshes[0]->getMeshBuffer(nr);
}
//! Returns pointer to a mesh buffer which fits a material
/** \param material: material to search for
\return Returns the pointer to the mesh buffer or
NULL if there is no such mesh buffer. */
IMeshBuffer *getMeshBuffer(const video::SMaterial &material) const override
{
if (Meshes.empty())
return 0;
return Meshes[0]->getMeshBuffer(material);
}
//! set the hardware mapping hint, for driver
void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer = EBT_VERTEX_AND_INDEX) override
{
for (u32 i = 0; i < Meshes.size(); ++i)
Meshes[i]->setHardwareMappingHint(newMappingHint, buffer);
}
//! flags the meshbuffer as changed, reloads hardware buffers
void setDirty(E_BUFFER_TYPE buffer = EBT_VERTEX_AND_INDEX) override
{
for (u32 i = 0; i < Meshes.size(); ++i)
Meshes[i]->setDirty(buffer);
}
//! All meshes defining the animated mesh
core::array<IMesh *> Meshes;
//! The bounding box of this mesh
core::aabbox3d<f32> Box;
//! Default animation speed of this mesh.
f32 FramesPerSecond;
//! The type of the mesh.
E_ANIMATED_MESH_TYPE Type;
};
} // end namespace scene
} // end namespace irr

728
irr/include/SColor.h Normal file
View File

@ -0,0 +1,728 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "irrTypes.h"
#include "irrMath.h"
namespace irr
{
namespace video
{
//! An enum for the color format of textures used by the Irrlicht Engine.
/** A color format specifies how color information is stored.
NOTE: Byte order in memory is usually flipped (it's probably correct in bitmap files, but flipped on reading).
So for example ECF_A8R8G8B8 is BGRA in memory same as in DX9's D3DFMT_A8R8G8B8 format.
*/
enum ECOLOR_FORMAT
{
//! 16 bit color format used by the software driver.
/** It is thus preferred by all other irrlicht engine video drivers.
There are 5 bits for every color component, and a single bit is left
for alpha information. */
ECF_A1R5G5B5 = 0,
//! Standard 16 bit color format.
ECF_R5G6B5,
//! 24 bit color, no alpha channel, but 8 bit for red, green and blue.
//! Warning: 24 bit formats tend to be badly supported. Depending on driver it's usually converted to another
// format or even not working at all. It's mostly better to use 16-bit or 32-bit formats.
ECF_R8G8B8,
//! Default 32 bit color format. 8 bits are used for every component: red, green, blue and alpha.
//! Warning: This tends to be BGRA in memory (it's ARGB on file, but with usual big-endian memory it's flipped)
ECF_A8R8G8B8,
/** The following formats may only be used for render target textures. */
/** Floating point formats. */
//! 16 bit format using 16 bits for the red channel.
ECF_R16F,
//! 32 bit format using 16 bits for the red and green channels.
ECF_G16R16F,
//! 64 bit format using 16 bits for the red, green, blue and alpha channels.
ECF_A16B16G16R16F,
//! 32 bit format using 32 bits for the red channel.
ECF_R32F,
//! 64 bit format using 32 bits for the red and green channels.
ECF_G32R32F,
//! 128 bit format using 32 bits for the red, green, blue and alpha channels.
ECF_A32B32G32R32F,
/** Unsigned normalized integer formats. */
//! 8 bit format using 8 bits for the red channel.
ECF_R8,
//! 16 bit format using 8 bits for the red and green channels.
ECF_R8G8,
//! 16 bit format using 16 bits for the red channel.
ECF_R16,
//! 32 bit format using 16 bits for the red and green channels.
ECF_R16G16,
/** Depth and stencil formats. */
//! 16 bit format using 16 bits for depth.
ECF_D16,
//! 32 bit format using 32 bits for depth.
ECF_D32,
//! 32 bit format using 24 bits for depth and 8 bits for stencil.
ECF_D24S8,
//! Unknown color format:
ECF_UNKNOWN
};
//! Names for ECOLOR_FORMAT types
const c8 *const ColorFormatNames[ECF_UNKNOWN + 2] = {
"A1R5G5B5",
"R5G6B5",
"R8G8B8",
"A8R8G8B8",
"R16F",
"G16R16F",
"A16B16G16R16F",
"R32F",
"G32R32F",
"A32B32G32R32F",
"R8",
"R8G8",
"R16",
"R16G16",
"D16",
"D32",
"D24S8",
"UNKNOWN",
0,
};
//! Creates a 16 bit A1R5G5B5 color
inline u16 RGBA16(u32 r, u32 g, u32 b, u32 a = 0xFF)
{
return (u16)((a & 0x80) << 8 |
(r & 0xF8) << 7 |
(g & 0xF8) << 2 |
(b & 0xF8) >> 3);
}
//! Creates a 16 bit A1R5G5B5 color
inline u16 RGB16(u32 r, u32 g, u32 b)
{
return RGBA16(r, g, b);
}
//! Creates a 16bit A1R5G5B5 color, based on 16bit input values
inline u16 RGB16from16(u16 r, u16 g, u16 b)
{
return (0x8000 |
(r & 0x1F) << 10 |
(g & 0x1F) << 5 |
(b & 0x1F));
}
//! Converts a 32bit (X8R8G8B8) color to a 16bit A1R5G5B5 color
inline u16 X8R8G8B8toA1R5G5B5(u32 color)
{
return (u16)(0x8000 |
(color & 0x00F80000) >> 9 |
(color & 0x0000F800) >> 6 |
(color & 0x000000F8) >> 3);
}
//! Converts a 32bit (A8R8G8B8) color to a 16bit A1R5G5B5 color
inline u16 A8R8G8B8toA1R5G5B5(u32 color)
{
return (u16)((color & 0x80000000) >> 16 |
(color & 0x00F80000) >> 9 |
(color & 0x0000F800) >> 6 |
(color & 0x000000F8) >> 3);
}
//! Converts a 32bit (A8R8G8B8) color to a 16bit R5G6B5 color
inline u16 A8R8G8B8toR5G6B5(u32 color)
{
return (u16)((color & 0x00F80000) >> 8 |
(color & 0x0000FC00) >> 5 |
(color & 0x000000F8) >> 3);
}
//! Convert A8R8G8B8 Color from A1R5G5B5 color
/** build a nicer 32bit Color by extending dest lower bits with source high bits. */
inline u32 A1R5G5B5toA8R8G8B8(u16 color)
{
return (((-((s32)color & 0x00008000) >> (s32)31) & 0xFF000000) |
((color & 0x00007C00) << 9) | ((color & 0x00007000) << 4) |
((color & 0x000003E0) << 6) | ((color & 0x00000380) << 1) |
((color & 0x0000001F) << 3) | ((color & 0x0000001C) >> 2));
}
//! Returns A8R8G8B8 Color from R5G6B5 color
inline u32 R5G6B5toA8R8G8B8(u16 color)
{
return 0xFF000000 |
((color & 0xF800) << 8) |
((color & 0x07E0) << 5) |
((color & 0x001F) << 3);
}
//! Returns A1R5G5B5 Color from R5G6B5 color
inline u16 R5G6B5toA1R5G5B5(u16 color)
{
return 0x8000 | (((color & 0xFFC0) >> 1) | (color & 0x1F));
}
//! Returns R5G6B5 Color from A1R5G5B5 color
inline u16 A1R5G5B5toR5G6B5(u16 color)
{
return (((color & 0x7FE0) << 1) | (color & 0x1F));
}
//! Returns the alpha component from A1R5G5B5 color
/** In Irrlicht, alpha refers to opacity.
\return The alpha value of the color. 0 is transparent, 1 is opaque. */
inline u32 getAlpha(u16 color)
{
return ((color >> 15) & 0x1);
}
//! Returns the red component from A1R5G5B5 color.
/** Shift left by 3 to get 8 bit value. */
inline u32 getRed(u16 color)
{
return ((color >> 10) & 0x1F);
}
//! Returns the green component from A1R5G5B5 color
/** Shift left by 3 to get 8 bit value. */
inline u32 getGreen(u16 color)
{
return ((color >> 5) & 0x1F);
}
//! Returns the blue component from A1R5G5B5 color
/** Shift left by 3 to get 8 bit value. */
inline u32 getBlue(u16 color)
{
return (color & 0x1F);
}
//! Returns the average from a 16 bit A1R5G5B5 color
inline s32 getAverage(s16 color)
{
return ((getRed(color) << 3) + (getGreen(color) << 3) + (getBlue(color) << 3)) / 3;
}
//! Class representing a 32 bit ARGB color.
/** The color values for alpha, red, green, and blue are
stored in a single u32. So all four values may be between 0 and 255.
Alpha in Irrlicht is opacity, so 0 is fully transparent, 255 is fully opaque (solid).
This class is used by most parts of the Irrlicht Engine
to specify a color. Another way is using the class SColorf, which
stores the color values in 4 floats.
This class must consist of only one u32 and must not use virtual functions.
*/
class SColor
{
public:
//! Constructor of the Color. Does nothing.
/** The color value is not initialized to save time. */
SColor() {}
//! Constructs the color from 4 values representing the alpha, red, green and blue component.
/** Must be values between 0 and 255. */
constexpr SColor(u32 a, u32 r, u32 g, u32 b) :
color(((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff)) {}
//! Constructs the color from a 32 bit value. Could be another color.
constexpr SColor(u32 clr) :
color(clr) {}
//! Returns the alpha component of the color.
/** The alpha component defines how opaque a color is.
\return The alpha value of the color. 0 is fully transparent, 255 is fully opaque. */
u32 getAlpha() const { return color >> 24; }
//! Returns the red component of the color.
/** \return Value between 0 and 255, specifying how red the color is.
0 means no red, 255 means full red. */
u32 getRed() const { return (color >> 16) & 0xff; }
//! Returns the green component of the color.
/** \return Value between 0 and 255, specifying how green the color is.
0 means no green, 255 means full green. */
u32 getGreen() const { return (color >> 8) & 0xff; }
//! Returns the blue component of the color.
/** \return Value between 0 and 255, specifying how blue the color is.
0 means no blue, 255 means full blue. */
u32 getBlue() const { return color & 0xff; }
//! Get lightness of the color in the range [0,255]
f32 getLightness() const
{
return 0.5f * (core::max_(core::max_(getRed(), getGreen()), getBlue()) + core::min_(core::min_(getRed(), getGreen()), getBlue()));
}
//! Get luminance of the color in the range [0,255].
f32 getLuminance() const
{
return 0.3f * getRed() + 0.59f * getGreen() + 0.11f * getBlue();
}
//! Get average intensity of the color in the range [0,255].
u32 getAverage() const
{
return (getRed() + getGreen() + getBlue()) / 3;
}
//! Sets the alpha component of the Color.
/** The alpha component defines how transparent a color should be.
\param a The alpha value of the color. 0 is fully transparent, 255 is fully opaque. */
void setAlpha(u32 a) { color = ((a & 0xff) << 24) | (color & 0x00ffffff); }
//! Sets the red component of the Color.
/** \param r: Has to be a value between 0 and 255.
0 means no red, 255 means full red. */
void setRed(u32 r) { color = ((r & 0xff) << 16) | (color & 0xff00ffff); }
//! Sets the green component of the Color.
/** \param g: Has to be a value between 0 and 255.
0 means no green, 255 means full green. */
void setGreen(u32 g) { color = ((g & 0xff) << 8) | (color & 0xffff00ff); }
//! Sets the blue component of the Color.
/** \param b: Has to be a value between 0 and 255.
0 means no blue, 255 means full blue. */
void setBlue(u32 b) { color = (b & 0xff) | (color & 0xffffff00); }
//! Calculates a 16 bit A1R5G5B5 value of this color.
/** \return 16 bit A1R5G5B5 value of this color. */
u16 toA1R5G5B5() const { return A8R8G8B8toA1R5G5B5(color); }
//! Converts color to OpenGL color format
/** From ARGB to RGBA in 4 byte components for endian aware
passing to OpenGL
\param dest: address where the 4x8 bit OpenGL color is stored. */
void toOpenGLColor(u8 *dest) const
{
*dest = (u8)getRed();
*++dest = (u8)getGreen();
*++dest = (u8)getBlue();
*++dest = (u8)getAlpha();
}
//! Sets all four components of the color at once.
/** Constructs the color from 4 values representing the alpha,
red, green and blue components of the color. Must be values
between 0 and 255.
\param a: Alpha component of the color. The alpha component
defines how transparent a color should be. Has to be a value
between 0 and 255. 255 means not transparent (opaque), 0 means
fully transparent.
\param r: Sets the red component of the Color. Has to be a
value between 0 and 255. 0 means no red, 255 means full red.
\param g: Sets the green component of the Color. Has to be a
value between 0 and 255. 0 means no green, 255 means full
green.
\param b: Sets the blue component of the Color. Has to be a
value between 0 and 255. 0 means no blue, 255 means full blue. */
void set(u32 a, u32 r, u32 g, u32 b)
{
color = (((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff));
}
void set(u32 col) { color = col; }
//! Compares the color to another color.
/** \return True if the colors are the same, and false if not. */
bool operator==(const SColor &other) const { return other.color == color; }
//! Compares the color to another color.
/** \return True if the colors are different, and false if they are the same. */
bool operator!=(const SColor &other) const { return other.color != color; }
//! comparison operator
/** \return True if this color is smaller than the other one */
bool operator<(const SColor &other) const { return (color < other.color); }
//! Adds two colors, result is clamped to 0..255 values
/** \param other Color to add to this color
\return Addition of the two colors, clamped to 0..255 values */
SColor operator+(const SColor &other) const
{
return SColor(core::min_(getAlpha() + other.getAlpha(), 255u),
core::min_(getRed() + other.getRed(), 255u),
core::min_(getGreen() + other.getGreen(), 255u),
core::min_(getBlue() + other.getBlue(), 255u));
}
//! Interpolates the color with a f32 value to another color
/** \param other: Other color
\param d: value between 0.0f and 1.0f. d=0 returns other, d=1 returns this, values between interpolate.
\return Interpolated color. */
SColor getInterpolated(const SColor &other, f32 d) const
{
d = core::clamp(d, 0.f, 1.f);
const f32 inv = 1.0f - d;
return SColor((u32)core::round32(other.getAlpha() * inv + getAlpha() * d),
(u32)core::round32(other.getRed() * inv + getRed() * d),
(u32)core::round32(other.getGreen() * inv + getGreen() * d),
(u32)core::round32(other.getBlue() * inv + getBlue() * d));
}
//! Returns interpolated color. ( quadratic )
/** \param c1: first color to interpolate with
\param c2: second color to interpolate with
\param d: value between 0.0f and 1.0f. */
SColor getInterpolated_quadratic(const SColor &c1, const SColor &c2, f32 d) const
{
// this*(1-d)*(1-d) + 2 * c1 * (1-d) + c2 * d * d;
d = core::clamp(d, 0.f, 1.f);
const f32 inv = 1.f - d;
const f32 mul0 = inv * inv;
const f32 mul1 = 2.f * d * inv;
const f32 mul2 = d * d;
return SColor(
core::clamp(core::floor32(
getAlpha() * mul0 + c1.getAlpha() * mul1 + c2.getAlpha() * mul2),
0, 255),
core::clamp(core::floor32(
getRed() * mul0 + c1.getRed() * mul1 + c2.getRed() * mul2),
0, 255),
core::clamp(core::floor32(
getGreen() * mul0 + c1.getGreen() * mul1 + c2.getGreen() * mul2),
0, 255),
core::clamp(core::floor32(
getBlue() * mul0 + c1.getBlue() * mul1 + c2.getBlue() * mul2),
0, 255));
}
//! set the color by expecting data in the given format
/** \param data: must point to valid memory containing color information in the given format
\param format: tells the format in which data is available
*/
void setData(const void *data, ECOLOR_FORMAT format)
{
switch (format) {
case ECF_A1R5G5B5:
color = A1R5G5B5toA8R8G8B8(*(u16 *)data);
break;
case ECF_R5G6B5:
color = R5G6B5toA8R8G8B8(*(u16 *)data);
break;
case ECF_A8R8G8B8:
color = *(u32 *)data;
break;
case ECF_R8G8B8: {
const u8 *p = (u8 *)data;
set(255, p[0], p[1], p[2]);
} break;
default:
color = 0xffffffff;
break;
}
}
//! Write the color to data in the defined format
/** \param data: target to write the color. Must contain sufficiently large memory to receive the number of bytes neede for format
\param format: tells the format used to write the color into data
*/
void getData(void *data, ECOLOR_FORMAT format) const
{
switch (format) {
case ECF_A1R5G5B5: {
u16 *dest = (u16 *)data;
*dest = video::A8R8G8B8toA1R5G5B5(color);
} break;
case ECF_R5G6B5: {
u16 *dest = (u16 *)data;
*dest = video::A8R8G8B8toR5G6B5(color);
} break;
case ECF_R8G8B8: {
u8 *dest = (u8 *)data;
dest[0] = (u8)getRed();
dest[1] = (u8)getGreen();
dest[2] = (u8)getBlue();
} break;
case ECF_A8R8G8B8: {
u32 *dest = (u32 *)data;
*dest = color;
} break;
default:
break;
}
}
//! color in A8R8G8B8 Format
u32 color;
};
//! Class representing a color with four floats.
/** The color values for red, green, blue
and alpha are each stored in a 32 bit floating point variable.
So all four values may be between 0.0f and 1.0f.
Another, faster way to define colors is using the class SColor, which
stores the color values in a single 32 bit integer.
*/
class SColorf
{
public:
//! Default constructor for SColorf.
/** Sets red, green and blue to 0.0f and alpha to 1.0f. */
SColorf() :
r(0.0f), g(0.0f), b(0.0f), a(1.0f) {}
//! Constructs a color from up to four color values: red, green, blue, and alpha.
/** \param r: Red color component. Should be a value between
0.0f meaning no red and 1.0f, meaning full red.
\param g: Green color component. Should be a value between 0.0f
meaning no green and 1.0f, meaning full green.
\param b: Blue color component. Should be a value between 0.0f
meaning no blue and 1.0f, meaning full blue.
\param a: Alpha color component of the color. The alpha
component defines how transparent a color should be. Has to be
a value between 0.0f and 1.0f, 1.0f means not transparent
(opaque), 0.0f means fully transparent. */
SColorf(f32 r, f32 g, f32 b, f32 a = 1.0f) :
r(r), g(g), b(b), a(a) {}
//! Constructs a color from 32 bit Color.
/** \param c: 32 bit color from which this SColorf class is
constructed from. */
SColorf(SColor c)
{
const f32 inv = 1.0f / 255.0f;
r = c.getRed() * inv;
g = c.getGreen() * inv;
b = c.getBlue() * inv;
a = c.getAlpha() * inv;
}
//! Converts this color to a SColor without floats.
SColor toSColor() const
{
return SColor((u32)core::round32(a * 255.0f), (u32)core::round32(r * 255.0f), (u32)core::round32(g * 255.0f), (u32)core::round32(b * 255.0f));
}
//! Sets three color components to new values at once.
/** \param rr: Red color component. Should be a value between 0.0f meaning
no red (=black) and 1.0f, meaning full red.
\param gg: Green color component. Should be a value between 0.0f meaning
no green (=black) and 1.0f, meaning full green.
\param bb: Blue color component. Should be a value between 0.0f meaning
no blue (=black) and 1.0f, meaning full blue. */
void set(f32 rr, f32 gg, f32 bb)
{
r = rr;
g = gg;
b = bb;
}
//! Sets all four color components to new values at once.
/** \param aa: Alpha component. Should be a value between 0.0f meaning
fully transparent and 1.0f, meaning opaque.
\param rr: Red color component. Should be a value between 0.0f meaning
no red and 1.0f, meaning full red.
\param gg: Green color component. Should be a value between 0.0f meaning
no green and 1.0f, meaning full green.
\param bb: Blue color component. Should be a value between 0.0f meaning
no blue and 1.0f, meaning full blue. */
void set(f32 aa, f32 rr, f32 gg, f32 bb)
{
a = aa;
r = rr;
g = gg;
b = bb;
}
//! Interpolates the color with a f32 value to another color
/** \param other: Other color
\param d: value between 0.0f and 1.0f
\return Interpolated color. */
SColorf getInterpolated(const SColorf &other, f32 d) const
{
d = core::clamp(d, 0.f, 1.f);
const f32 inv = 1.0f - d;
return SColorf(other.r * inv + r * d,
other.g * inv + g * d, other.b * inv + b * d, other.a * inv + a * d);
}
//! Returns interpolated color. ( quadratic )
/** \param c1: first color to interpolate with
\param c2: second color to interpolate with
\param d: value between 0.0f and 1.0f. */
inline SColorf getInterpolated_quadratic(const SColorf &c1, const SColorf &c2,
f32 d) const
{
d = core::clamp(d, 0.f, 1.f);
// this*(1-d)*(1-d) + 2 * c1 * (1-d) + c2 * d * d;
const f32 inv = 1.f - d;
const f32 mul0 = inv * inv;
const f32 mul1 = 2.f * d * inv;
const f32 mul2 = d * d;
return SColorf(r * mul0 + c1.r * mul1 + c2.r * mul2,
g * mul0 + c1.g * mul1 + c2.g * mul2,
b * mul0 + c1.b * mul1 + c2.b * mul2,
a * mul0 + c1.a * mul1 + c2.a * mul2);
}
//! Sets a color component by index. R=0, G=1, B=2, A=3
void setColorComponentValue(s32 index, f32 value)
{
switch (index) {
case 0:
r = value;
break;
case 1:
g = value;
break;
case 2:
b = value;
break;
case 3:
a = value;
break;
}
}
//! Returns the alpha component of the color in the range 0.0 (transparent) to 1.0 (opaque)
f32 getAlpha() const { return a; }
//! Returns the red component of the color in the range 0.0 to 1.0
f32 getRed() const { return r; }
//! Returns the green component of the color in the range 0.0 to 1.0
f32 getGreen() const { return g; }
//! Returns the blue component of the color in the range 0.0 to 1.0
f32 getBlue() const { return b; }
//! red color component
f32 r;
//! green color component
f32 g;
//! blue component
f32 b;
//! alpha color component
f32 a;
};
//! Class representing a color in HSL format
/** The color values for hue, saturation, luminance
are stored in 32bit floating point variables. Hue is in range [0,360],
Luminance and Saturation are in percent [0,100]
*/
class SColorHSL
{
public:
constexpr SColorHSL(f32 h = 0.f, f32 s = 0.f, f32 l = 0.f) :
Hue(h), Saturation(s), Luminance(l) {}
void fromRGB(const SColorf &color);
void toRGB(SColorf &color) const;
f32 Hue;
f32 Saturation;
f32 Luminance;
private:
inline f32 toRGB1(f32 rm1, f32 rm2, f32 rh) const;
};
inline void SColorHSL::fromRGB(const SColorf &color)
{
const f32 maxVal = core::max_(color.getRed(), color.getGreen(), color.getBlue());
const f32 minVal = (f32)core::min_(color.getRed(), color.getGreen(), color.getBlue());
Luminance = (maxVal + minVal) * 50;
if (core::equals(maxVal, minVal)) {
Hue = 0.f;
Saturation = 0.f;
return;
}
const f32 delta = maxVal - minVal;
if (Luminance <= 50) {
Saturation = (delta) / (maxVal + minVal);
} else {
Saturation = (delta) / (2 - maxVal - minVal);
}
Saturation *= 100;
if (core::equals(maxVal, color.getRed()))
Hue = (color.getGreen() - color.getBlue()) / delta;
else if (core::equals(maxVal, color.getGreen()))
Hue = 2 + ((color.getBlue() - color.getRed()) / delta);
else // blue is max
Hue = 4 + ((color.getRed() - color.getGreen()) / delta);
Hue *= 60.0f;
while (Hue < 0.f)
Hue += 360;
}
inline void SColorHSL::toRGB(SColorf &color) const
{
const f32 l = Luminance / 100;
if (core::iszero(Saturation)) { // grey
color.set(l, l, l);
return;
}
f32 rm2;
if (Luminance <= 50) {
rm2 = l + l * (Saturation / 100);
} else {
rm2 = l + (1 - l) * (Saturation / 100);
}
const f32 rm1 = 2.0f * l - rm2;
const f32 h = Hue / 360.0f;
color.set(toRGB1(rm1, rm2, h + 1.f / 3.f),
toRGB1(rm1, rm2, h),
toRGB1(rm1, rm2, h - 1.f / 3.f));
}
// algorithm from Foley/Van-Dam
inline f32 SColorHSL::toRGB1(f32 rm1, f32 rm2, f32 rh) const
{
if (rh < 0)
rh += 1;
if (rh > 1)
rh -= 1;
if (rh < 1.f / 6.f)
rm1 = rm1 + (rm2 - rm1) * rh * 6.f;
else if (rh < 0.5f)
rm1 = rm2;
else if (rh < 2.f / 3.f)
rm1 = rm1 + (rm2 - rm1) * ((2.f / 3.f) - rh) * 6.f;
return rm1;
}
} // end namespace video
} // end namespace irr

89
irr/include/SExposedVideoData.h Normal file
View File

@ -0,0 +1,89 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
namespace irr
{
namespace video
{
//! structure for holding data describing a driver and operating system specific data.
/** This data can be retrieved by IVideoDriver::getExposedVideoData(). Use this with caution.
This only should be used to make it possible to extend the engine easily without
modification of its source. Note that this structure does not contain any valid data, if
you are using the software or the null device.
*/
struct SExposedVideoData
{
SExposedVideoData()
{
OpenGLWin32.HDc = 0;
OpenGLWin32.HRc = 0;
OpenGLWin32.HWnd = 0;
}
explicit SExposedVideoData(void *Window)
{
OpenGLWin32.HDc = 0;
OpenGLWin32.HRc = 0;
OpenGLWin32.HWnd = Window;
}
struct SOpenGLWin32
{
//! Private GDI Device Context.
/** Get if for example with: HDC h = reinterpret_cast<HDC>(exposedData.OpenGLWin32.HDc) */
void *HDc;
//! Permanent Rendering Context.
/** Get if for example with: HGLRC h = reinterpret_cast<HGLRC>(exposedData.OpenGLWin32.HRc) */
void *HRc;
//! Window handle.
/** Get with for example with: HWND h = reinterpret_cast<HWND>(exposedData.OpenGLWin32.HWnd) */
void *HWnd;
};
struct SOpenGLLinux
{
// XWindow handles
void *X11Display;
void *X11Context;
unsigned long X11Window;
unsigned long GLXWindow;
};
struct SOpenGLOSX
{
//! The NSOpenGLContext object.
void *Context;
//! The NSWindow object.
void *Window;
};
struct SOpenGLFB
{
//! The EGLNativeWindowType object.
void *Window;
};
struct SOGLESAndroid
{
//! The ANativeWindow object.
void *Window;
};
union
{
SOpenGLWin32 OpenGLWin32;
SOpenGLLinux OpenGLLinux;
SOpenGLOSX OpenGLOSX;
SOpenGLFB OpenGLFB;
SOGLESAndroid OGLESAndroid;
};
};
} // end namespace video
} // end namespace irr

267
irr/include/SIrrCreationParameters.h Normal file
View File

@ -0,0 +1,267 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "EDriverTypes.h"
#include "EDeviceTypes.h"
#include "dimension2d.h"
#include "ILogger.h"
#include "position2d.h"
#include "path.h"
#include "IrrCompileConfig.h" // for IRRLICHT_SDK_VERSION
namespace irr
{
class IEventReceiver;
//! Structure for holding Irrlicht Device creation parameters.
/** This structure is used in the createDeviceEx() function. */
struct SIrrlichtCreationParameters
{
//! Constructs a SIrrlichtCreationParameters structure with default values.
SIrrlichtCreationParameters() :
DeviceType(EIDT_BEST),
DriverType(video::EDT_OPENGL),
WindowSize(core::dimension2d<u32>(800, 600)),
WindowPosition(core::position2di(-1, -1)),
Bits(32),
ZBufferBits(24),
Fullscreen(false),
WindowMaximized(false),
WindowResizable(2),
Stencilbuffer(true),
Vsync(false),
AntiAlias(0),
WithAlphaChannel(false),
Doublebuffer(true),
Stereobuffer(false),
EventReceiver(0),
WindowId(0),
#ifdef _DEBUG
LoggingLevel(ELL_DEBUG),
#else
LoggingLevel(ELL_INFORMATION),
#endif
SDK_version_do_not_use(IRRLICHT_SDK_VERSION),
PrivateData(0),
#ifdef IRR_MOBILE_PATHS
OGLES2ShaderPath("media/Shaders/")
#else
OGLES2ShaderPath("../../media/Shaders/")
#endif
{
}
SIrrlichtCreationParameters(const SIrrlichtCreationParameters &other) :
SDK_version_do_not_use(IRRLICHT_SDK_VERSION)
{
*this = other;
}
SIrrlichtCreationParameters &operator=(const SIrrlichtCreationParameters &other)
{
DeviceType = other.DeviceType;
DriverType = other.DriverType;
WindowSize = other.WindowSize;
WindowPosition = other.WindowPosition;
Bits = other.Bits;
ZBufferBits = other.ZBufferBits;
Fullscreen = other.Fullscreen;
WindowMaximized = other.WindowMaximized;
WindowResizable = other.WindowResizable;
Stencilbuffer = other.Stencilbuffer;
Vsync = other.Vsync;
AntiAlias = other.AntiAlias;
WithAlphaChannel = other.WithAlphaChannel;
Doublebuffer = other.Doublebuffer;
Stereobuffer = other.Stereobuffer;
EventReceiver = other.EventReceiver;
WindowId = other.WindowId;
LoggingLevel = other.LoggingLevel;
PrivateData = other.PrivateData;
OGLES2ShaderPath = other.OGLES2ShaderPath;
return *this;
}
//! Type of the device.
/** This setting decides the windowing system used by the device, most device types are native
to a specific operating system and so may not be available.
EIDT_WIN32 is only available on Windows desktops,
EIDT_COCOA is only available on Mac OSX,
EIDT_X11 is available on Linux, Solaris, BSD and other operating systems which use X11,
EIDT_SDL is available on most systems if compiled in,
EIDT_BEST will select the best available device for your operating system.
Default: EIDT_BEST. */
E_DEVICE_TYPE DeviceType;
//! Type of video driver used to render graphics.
video::E_DRIVER_TYPE DriverType;
//! Size of the window or the video mode in fullscreen mode. Default: 800x600
core::dimension2d<u32> WindowSize;
//! Position of the window on-screen. Default: (-1, -1) or centered.
core::position2di WindowPosition;
//! Minimum Bits per pixel of the color buffer in fullscreen mode. Ignored if windowed mode. Default: 32.
u8 Bits;
//! Minimum Bits per pixel of the depth buffer. Default: 24.
u8 ZBufferBits;
//! Should be set to true if the device should run in fullscreen.
/** Otherwise the device runs in windowed mode. Default: false. */
bool Fullscreen;
//! Maximised window. (Only supported on SDL.) Default: false
bool WindowMaximized;
//! Should a non-fullscreen window be resizable.
/** Might not be supported by all devices. Ignored when Fullscreen is true.
Values: 0 = not resizable, 1 = resizable, 2 = system decides default itself
Default: 2*/
u8 WindowResizable;
//! Specifies if the stencil buffer should be enabled.
/** Set this to true, if you want the engine be able to draw
stencil buffer shadows. Note that not all drivers are able to
use the stencil buffer, hence it can be ignored during device
creation. Without the stencil buffer no shadows will be drawn.
Default: true. */
bool Stencilbuffer;
//! Specifies vertical synchronization.
/** If set to true, the driver will wait for the vertical
retrace period, otherwise not. May be silently ignored.
Default: false */
bool Vsync;
//! Specifies if the device should use fullscreen anti aliasing
/** Makes sharp/pixelated edges softer, but requires more
performance. Also, 2D elements might look blurred with this
switched on. The resulting rendering quality also depends on
the hardware and driver you are using, your program might look
different on different hardware with this. So if you are
writing a game/application with AntiAlias switched on, it would
be a good idea to make it possible to switch this option off
again by the user.
The value is the maximal antialiasing factor requested for
the device. The creation method will automatically try smaller
values if no window can be created with the given value.
Value one is usually the same as 0 (disabled), but might be a
special value on some platforms. On D3D devices it maps to
NONMASKABLE.
Default value: 0 - disabled */
u8 AntiAlias;
//! Whether the main framebuffer uses an alpha channel.
/** In some situations it might be desirable to get a color
buffer with an alpha channel, e.g. when rendering into a
transparent window or overlay. If this flag is set the device
tries to create a framebuffer with alpha channel.
If this flag is set, only color buffers with alpha channel
are considered. Otherwise, it depends on the actual hardware
if the colorbuffer has an alpha channel or not.
Default value: false */
bool WithAlphaChannel;
//! Whether the main framebuffer uses doublebuffering.
/** This should be usually enabled, in order to avoid render
artifacts on the visible framebuffer. However, it might be
useful to use only one buffer on very small devices. If no
doublebuffering is available, the drivers will fall back to
single buffers. Default value: true */
bool Doublebuffer;
//! Specifies if the device should use stereo buffers
/** Some high-end gfx cards support two framebuffers for direct
support of stereoscopic output devices. If this flag is set the
device tries to create a stereo context.
Currently only supported by OpenGL.
Default value: false */
bool Stereobuffer;
//! A user created event receiver.
IEventReceiver *EventReceiver;
//! Window Id.
/** If this is set to a value other than 0, the Irrlicht Engine
will be created in an already existing window.
For Windows, set this to the HWND of the window you want.
The windowSize and FullScreen options will be ignored when using
the WindowId parameter. Default this is set to 0.
To make Irrlicht run inside the custom window, you still will
have to draw Irrlicht on your own. You can use this loop, as
usual:
\code
while (device->run())
{
driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH, 0);
smgr->drawAll();
driver->endScene();
}
\endcode
Instead of this, you can also simply use your own message loop
using GetMessage, DispatchMessage and whatever. Calling
IrrlichtDevice::run() will cause Irrlicht to dispatch messages
internally too. You need not call Device->run() if you want to
do your own message dispatching loop, but Irrlicht will not be
able to fetch user input then and you have to do it on your own
using the window messages, DirectInput, or whatever. Also,
you'll have to increment the Irrlicht timer.
An alternative, own message dispatching loop without
device->run() would look like this:
\code
MSG msg;
while (true)
{
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
if (msg.message == WM_QUIT)
break;
}
// increase virtual timer time
device->getTimer()->tick();
// draw engine picture
driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH, 0);
smgr->drawAll();
driver->endScene();
}
\endcode
However, there is no need to draw the picture this often. Just
do it how you like. */
void *WindowId;
//! Specifies the logging level used in the logging interface.
/** The default value is ELL_INFORMATION. You can access the ILogger interface
later on from the IrrlichtDevice with getLogger() and set another level.
But if you need more or less logging information already from device creation,
then you have to change it here.
*/
ELOG_LEVEL LoggingLevel;
//! Don't use or change this parameter.
/** Always set it to IRRLICHT_SDK_VERSION, which is done by default.
This is needed for sdk version checks. */
const c8 *const SDK_version_do_not_use;
//! Define some private data storage.
/** Used when platform devices need access to OS specific data structures etc.
This is only used for Android at the moment in order to access the native
Java RE. */
void *PrivateData;
//! Set the path where default-shaders to simulate the fixed-function pipeline can be found.
/** This is about the shaders which can be found in media/Shaders by default. It's only necessary
to set when using OGL-ES 2.0 */
irr::io::path OGLES2ShaderPath;
};
} // end namespace irr

566
irr/include/SMaterial.h Normal file
View File

@ -0,0 +1,566 @@
// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#include "SColor.h"
#include "matrix4.h"
#include "irrArray.h"
#include "irrMath.h"
#include "EMaterialTypes.h"
#include "EMaterialProps.h"
#include "SMaterialLayer.h"
#include "IrrCompileConfig.h" // for IRRLICHT_API
namespace irr
{
namespace video
{
class ITexture;
//! Flag for MaterialTypeParam (in combination with EMT_ONETEXTURE_BLEND) or for BlendFactor
//! BlendFunc = source * sourceFactor + dest * destFactor
enum E_BLEND_FACTOR
{
EBF_ZERO = 0, //!< src & dest (0, 0, 0, 0)
EBF_ONE, //!< src & dest (1, 1, 1, 1)
EBF_DST_COLOR, //!< src (destR, destG, destB, destA)
EBF_ONE_MINUS_DST_COLOR, //!< src (1-destR, 1-destG, 1-destB, 1-destA)
EBF_SRC_COLOR, //!< dest (srcR, srcG, srcB, srcA)
EBF_ONE_MINUS_SRC_COLOR, //!< dest (1-srcR, 1-srcG, 1-srcB, 1-srcA)
EBF_SRC_ALPHA, //!< src & dest (srcA, srcA, srcA, srcA)
EBF_ONE_MINUS_SRC_ALPHA, //!< src & dest (1-srcA, 1-srcA, 1-srcA, 1-srcA)
EBF_DST_ALPHA, //!< src & dest (destA, destA, destA, destA)
EBF_ONE_MINUS_DST_ALPHA, //!< src & dest (1-destA, 1-destA, 1-destA, 1-destA)
EBF_SRC_ALPHA_SATURATE //!< src (min(srcA, 1-destA), idem, ...)
};
//! Values defining the blend operation
enum E_BLEND_OPERATION
{
EBO_NONE = 0, //!< No blending happens
EBO_ADD, //!< Default blending adds the color values
EBO_SUBTRACT, //!< This mode subtracts the color values
EBO_REVSUBTRACT, //!< This modes subtracts destination from source
EBO_MIN, //!< Choose minimum value of each color channel
EBO_MAX, //!< Choose maximum value of each color channel
EBO_MIN_FACTOR, //!< Choose minimum value of each color channel after applying blend factors, not widely supported
EBO_MAX_FACTOR, //!< Choose maximum value of each color channel after applying blend factors, not widely supported
EBO_MIN_ALPHA, //!< Choose minimum value of each color channel based on alpha value, not widely supported
EBO_MAX_ALPHA //!< Choose maximum value of each color channel based on alpha value, not widely supported
};
//! MaterialTypeParam: e.g. DirectX: D3DTOP_MODULATE, D3DTOP_MODULATE2X, D3DTOP_MODULATE4X
enum E_MODULATE_FUNC
{
EMFN_MODULATE_1X = 1,
EMFN_MODULATE_2X = 2,
EMFN_MODULATE_4X = 4
};
//! Comparison function, e.g. for depth buffer test
enum E_COMPARISON_FUNC
{
//! Depth test disabled (disable also write to depth buffer)
ECFN_DISABLED = 0,
//! <= test, default for e.g. depth test
ECFN_LESSEQUAL = 1,
//! Exact equality
ECFN_EQUAL = 2,
//! exclusive less comparison, i.e. <
ECFN_LESS,
//! Succeeds almost always, except for exact equality
ECFN_NOTEQUAL,
//! >= test
ECFN_GREATEREQUAL,
//! inverse of <=
ECFN_GREATER,
//! test succeeds always
ECFN_ALWAYS,
//! Test never succeeds
ECFN_NEVER
};
//! Enum values for enabling/disabling color planes for rendering
enum E_COLOR_PLANE
{
//! No color enabled
ECP_NONE = 0,
//! Alpha enabled
ECP_ALPHA = 1,
//! Red enabled
ECP_RED = 2,
//! Green enabled
ECP_GREEN = 4,
//! Blue enabled
ECP_BLUE = 8,
//! All colors, no alpha
ECP_RGB = 14,
//! All planes enabled
ECP_ALL = 15
};
//! Source of the alpha value to take
/** This is currently only supported in EMT_ONETEXTURE_BLEND. You can use an
or'ed combination of values. Alpha values are modulated (multiplied). */
enum E_ALPHA_SOURCE
{
//! Use no alpha, somewhat redundant with other settings
EAS_NONE = 0,
//! Use vertex color alpha
EAS_VERTEX_COLOR,
//! Use texture alpha channel
EAS_TEXTURE
};
//! Pack srcFact, dstFact, Modulate and alpha source to MaterialTypeParam or BlendFactor
/** alpha source can be an OR'ed combination of E_ALPHA_SOURCE values. */
inline f32 pack_textureBlendFunc(const E_BLEND_FACTOR srcFact, const E_BLEND_FACTOR dstFact,
const E_MODULATE_FUNC modulate = EMFN_MODULATE_1X, const u32 alphaSource = EAS_TEXTURE)
{
const u32 tmp = (alphaSource << 20) | (modulate << 16) | (srcFact << 12) | (dstFact << 8) | (srcFact << 4) | dstFact;
return FR(tmp);
}
//! Pack srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, Modulate and alpha source to MaterialTypeParam or BlendFactor
/** alpha source can be an OR'ed combination of E_ALPHA_SOURCE values. */
inline f32 pack_textureBlendFuncSeparate(const E_BLEND_FACTOR srcRGBFact, const E_BLEND_FACTOR dstRGBFact,
const E_BLEND_FACTOR srcAlphaFact, const E_BLEND_FACTOR dstAlphaFact,
const E_MODULATE_FUNC modulate = EMFN_MODULATE_1X, const u32 alphaSource = EAS_TEXTURE)
{
const u32 tmp = (alphaSource << 20) | (modulate << 16) | (srcAlphaFact << 12) | (dstAlphaFact << 8) | (srcRGBFact << 4) | dstRGBFact;
return FR(tmp);
}
//! Unpack srcFact, dstFact, modulo and alphaSource factors
/** The fields don't use the full byte range, so we could pack even more... */
inline void unpack_textureBlendFunc(E_BLEND_FACTOR &srcFact, E_BLEND_FACTOR &dstFact,
E_MODULATE_FUNC &modulo, u32 &alphaSource, const f32 param)
{
const u32 state = IR(param);
alphaSource = (state & 0x00F00000) >> 20;
modulo = E_MODULATE_FUNC((state & 0x000F0000) >> 16);
srcFact = E_BLEND_FACTOR((state & 0x000000F0) >> 4);
dstFact = E_BLEND_FACTOR((state & 0x0000000F));
}
//! Unpack srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulo and alphaSource factors
/** The fields don't use the full byte range, so we could pack even more... */
inline void unpack_textureBlendFuncSeparate(E_BLEND_FACTOR &srcRGBFact, E_BLEND_FACTOR &dstRGBFact,
E_BLEND_FACTOR &srcAlphaFact, E_BLEND_FACTOR &dstAlphaFact,
E_MODULATE_FUNC &modulo, u32 &alphaSource, const f32 param)
{
const u32 state = IR(param);
alphaSource = (state & 0x00F00000) >> 20;
modulo = E_MODULATE_FUNC((state & 0x000F0000) >> 16);
srcAlphaFact = E_BLEND_FACTOR((state & 0x0000F000) >> 12);
dstAlphaFact = E_BLEND_FACTOR((state & 0x00000F00) >> 8);
srcRGBFact = E_BLEND_FACTOR((state & 0x000000F0) >> 4);
dstRGBFact = E_BLEND_FACTOR((state & 0x0000000F));
}
//! has blend factor alphablending
inline bool textureBlendFunc_hasAlpha(const E_BLEND_FACTOR factor)
{
switch (factor) {
case EBF_SRC_ALPHA:
case EBF_ONE_MINUS_SRC_ALPHA:
case EBF_DST_ALPHA:
case EBF_ONE_MINUS_DST_ALPHA:
case EBF_SRC_ALPHA_SATURATE:
return true;
default:
return false;
}
}
//! These flags are used to specify the anti-aliasing and smoothing modes
/** Techniques supported are multisampling, geometry smoothing, and alpha
to coverage.
Some drivers don't support a per-material setting of the anti-aliasing
modes. In those cases, FSAA/multisampling is defined by the device mode
chosen upon creation via irr::SIrrCreationParameters.
*/
enum E_ANTI_ALIASING_MODE
{
//! Use to turn off anti-aliasing for this material
EAAM_OFF = 0,
//! Default anti-aliasing mode
EAAM_SIMPLE = 1,
//! High-quality anti-aliasing, not always supported, automatically enables SIMPLE mode
EAAM_QUALITY = 3,
//! Enhanced anti-aliasing for transparent materials
/** Usually used with EMT_TRANSPARENT_ALPHA_CHANNEL_REF and multisampling. */
EAAM_ALPHA_TO_COVERAGE = 4
};
//! These flags allow to define the interpretation of vertex color when lighting is enabled
/** Without lighting being enabled the vertex color is the only value defining the fragment color.
Once lighting is enabled, the four values for diffuse, ambient, emissive, and specular take over.
With these flags it is possible to define which lighting factor shall be defined by the vertex color
instead of the lighting factor which is the same for all faces of that material.
The default is to use vertex color for the diffuse value, another pretty common value is to use
vertex color for both diffuse and ambient factor. */
enum E_COLOR_MATERIAL
{
//! Don't use vertex color for lighting
ECM_NONE = 0,
//! Use vertex color for diffuse light, this is default
ECM_DIFFUSE,
//! Use vertex color for ambient light
ECM_AMBIENT,
//! Use vertex color for emissive light
ECM_EMISSIVE,
//! Use vertex color for specular light
ECM_SPECULAR,
//! Use vertex color for both diffuse and ambient light
ECM_DIFFUSE_AND_AMBIENT
};
//! Names for polygon offset direction
const c8 *const PolygonOffsetDirectionNames[] = {
"Back",
"Front",
0,
};
//! For SMaterial.ZWriteEnable
enum E_ZWRITE
{
//! zwrite always disabled for this material
EZW_OFF = 0,
//! This is the default setting for SMaterial and tries to handle things automatically.
//! This is what you want to set to enable zwriting.
//! Usually zwriting is enabled non-transparent materials - as far as Irrlicht can recognize those.
//! Basically Irrlicht tries to handle the zwriting for you and assumes transparent materials don't need it.
//! This is addionally affected by IVideoDriver::setAllowZWriteOnTransparent
EZW_AUTO,
//! zwrite always enabled for this material
EZW_ON
};
//! Names for E_ZWRITE
const c8 *const ZWriteNames[] = {
"Off",
"Auto",
"On",
0,
};
//! Maximum number of texture an SMaterial can have.
/** SMaterial might ignore some textures in most function, like assignment and comparison,
when SIrrlichtCreationParameters::MaxTextureUnits is set to a lower number.
*/
const u32 MATERIAL_MAX_TEXTURES = 4;
//! Struct for holding parameters for a material renderer
// Note for implementors: Serialization is in CNullDriver
class SMaterial
{
public:
//! Default constructor. Creates a solid, lit material with white colors
SMaterial() :
MaterialType(EMT_SOLID), AmbientColor(255, 255, 255, 255),
DiffuseColor(255, 255, 255, 255), EmissiveColor(0, 0, 0, 0),
SpecularColor(255, 255, 255, 255), Shininess(0.0f),
MaterialTypeParam(0.0f), Thickness(1.0f), ZBuffer(ECFN_LESSEQUAL),
AntiAliasing(EAAM_SIMPLE), ColorMask(ECP_ALL), ColorMaterial(ECM_DIFFUSE),
BlendOperation(EBO_NONE), BlendFactor(0.0f), PolygonOffsetDepthBias(0.f),
PolygonOffsetSlopeScale(0.f), Wireframe(false), PointCloud(false),
GouraudShading(true), Lighting(true), ZWriteEnable(EZW_AUTO),
BackfaceCulling(true), FrontfaceCulling(false), FogEnable(false),
NormalizeNormals(false), UseMipMaps(true)
{
}
//! Texture layer array.
SMaterialLayer TextureLayers[MATERIAL_MAX_TEXTURES];
//! Type of the material. Specifies how everything is blended together
E_MATERIAL_TYPE MaterialType;
//! How much ambient light (a global light) is reflected by this material.
/** The default is full white, meaning objects are completely
globally illuminated. Reduce this if you want to see diffuse
or specular light effects. */
SColor AmbientColor;
//! How much diffuse light coming from a light source is reflected by this material.
/** The default is full white. */
SColor DiffuseColor;
//! Light emitted by this material. Default is to emit no light.
SColor EmissiveColor;
//! How much specular light (highlights from a light) is reflected.
/** The default is to reflect white specular light. See
SMaterial::Shininess on how to enable specular lights. */
SColor SpecularColor;
//! Value affecting the size of specular highlights.
/** A value of 20 is common. If set to 0, no specular
highlights are being used. To activate, simply set the
shininess of a material to a value in the range [0.5;128]:
\code
sceneNode->getMaterial(0).Shininess = 20.0f;
\endcode
You can change the color of the highlights using
\code
sceneNode->getMaterial(0).SpecularColor.set(255,255,255,255);
\endcode
The specular color of the dynamic lights
(SLight::SpecularColor) will influence the the highlight color
too, but they are set to a useful value by default when
creating the light scene node.*/
f32 Shininess;
//! Free parameter, dependent on the material type.
/** Mostly ignored, used for example in
EMT_TRANSPARENT_ALPHA_CHANNEL and EMT_ONETEXTURE_BLEND. */
f32 MaterialTypeParam;
//! Thickness of non-3dimensional elements such as lines and points.
f32 Thickness;
//! Is the ZBuffer enabled? Default: ECFN_LESSEQUAL
/** If you want to disable depth test for this material
just set this parameter to ECFN_DISABLED.
Values are from E_COMPARISON_FUNC. */
u8 ZBuffer;
//! Sets the antialiasing mode
/** Values are chosen from E_ANTI_ALIASING_MODE. Default is
EAAM_SIMPLE, i.e. simple multi-sample anti-aliasing. */
u8 AntiAliasing;
//! Defines the enabled color planes
/** Values are defined as or'ed values of the E_COLOR_PLANE enum.
Only enabled color planes will be rendered to the current render
target. Typical use is to disable all colors when rendering only to
depth or stencil buffer, or using Red and Green for Stereo rendering. */
u8 ColorMask : 4;
//! Defines the interpretation of vertex color in the lighting equation
/** Values should be chosen from E_COLOR_MATERIAL.
When lighting is enabled, vertex color can be used instead of the
material values for light modulation. This allows to easily change e.g. the
diffuse light behavior of each face. The default, ECM_DIFFUSE, will result in
a very similar rendering as with lighting turned off, just with light shading. */
u8 ColorMaterial : 3;
//! Store the blend operation of choice
/** Values to be chosen from E_BLEND_OPERATION. */
E_BLEND_OPERATION BlendOperation : 4;
//! Store the blend factors
/** textureBlendFunc/textureBlendFuncSeparate functions should be used to write
properly blending factors to this parameter.
Due to historical reasons this parameter is not used for material type
EMT_ONETEXTURE_BLEND which uses MaterialTypeParam instead for the blend factor.
It's generally used only for materials without any blending otherwise (like EMT_SOLID).
It's main use is to allow having shader materials which can enable/disable
blending after they have been created.
When you set this you usually also have to set BlendOperation to a value != EBO_NONE
(setting it to EBO_ADD is probably the most common one value). */
f32 BlendFactor;
//! A constant z-buffer offset for a polygon/line/point
/** The range of the value is driver specific.
On OpenGL you get units which are multiplied by the smallest value that is guaranteed to produce a resolvable offset.
On D3D9 you can pass a range between -1 and 1. But you should likely divide it by the range of the depthbuffer.
Like dividing by 65535.0 for a 16 bit depthbuffer. Thought it still might produce too large of a bias.
Some article (https://aras-p.info/blog/2008/06/12/depth-bias-and-the-power-of-deceiving-yourself/)
recommends multiplying by 2.0*4.8e-7 (and strangely on both 16 bit and 24 bit). */
f32 PolygonOffsetDepthBias;
//! Variable Z-Buffer offset based on the slope of the polygon.
/** For polygons looking flat at a camera you could use 0 (for example in a 2D game)
But in most cases you will have polygons rendered at a certain slope.
The driver will calculate the slope for you and this value allows to scale that slope.
The complete polygon offset is: PolygonOffsetSlopeScale*slope + PolygonOffsetDepthBias
A good default here is to use 1.f if you want to push the polygons away from the camera
and -1.f to pull them towards the camera. */
f32 PolygonOffsetSlopeScale;
//! Draw as wireframe or filled triangles? Default: false
bool Wireframe : 1;
//! Draw as point cloud or filled triangles? Default: false
bool PointCloud : 1;
//! Flat or Gouraud shading? Default: true
bool GouraudShading : 1;
//! Will this material be lighted? Default: true
bool Lighting : 1;
//! Is the zbuffer writable or is it read-only. Default: EZW_AUTO.
/** If this parameter is not EZW_OFF, you probably also want to set ZBuffer
to values other than ECFN_DISABLED */
E_ZWRITE ZWriteEnable : 2;
//! Is backface culling enabled? Default: true
bool BackfaceCulling : 1;
//! Is frontface culling enabled? Default: false
bool FrontfaceCulling : 1;
//! Is fog enabled? Default: false
bool FogEnable : 1;
//! Should normals be normalized?
/** Always use this if the mesh lit and scaled. Default: false */
bool NormalizeNormals : 1;
//! Shall mipmaps be used if available
/** Sometimes, disabling mipmap usage can be useful. Default: true */
bool UseMipMaps : 1;
//! Execute a function on all texture layers.
/** Useful for setting properties which are not per material, but per
texture layer, e.g. bilinear filtering. */
template <typename F>
void forEachTexture(F &&fn)
{
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; i++) {
fn(TextureLayers[i]);
}
}
//! Gets the texture transformation matrix for level i
/** \param i The desired level. Must not be larger than MATERIAL_MAX_TEXTURES
\return Texture matrix for texture level i. */
core::matrix4 &getTextureMatrix(u32 i)
{
return TextureLayers[i].getTextureMatrix();
}
//! Gets the immutable texture transformation matrix for level i
/** \param i The desired level.
\return Texture matrix for texture level i, or identity matrix for levels larger than MATERIAL_MAX_TEXTURES. */
const core::matrix4 &getTextureMatrix(u32 i) const
{
if (i < MATERIAL_MAX_TEXTURES)
return TextureLayers[i].getTextureMatrix();
else
return core::IdentityMatrix;
}
//! Sets the i-th texture transformation matrix
/** \param i The desired level.
\param mat Texture matrix for texture level i. */
void setTextureMatrix(u32 i, const core::matrix4 &mat)
{
if (i >= MATERIAL_MAX_TEXTURES)
return;
TextureLayers[i].setTextureMatrix(mat);
}
//! Gets the i-th texture
/** \param i The desired level.
\return Texture for texture level i, if defined, else 0. */
ITexture *getTexture(u32 i) const
{
return i < MATERIAL_MAX_TEXTURES ? TextureLayers[i].Texture : 0;
}
//! Sets the i-th texture
/** If i>=MATERIAL_MAX_TEXTURES this setting will be ignored.
\param i The desired level.
\param tex Texture for texture level i. */
void setTexture(u32 i, ITexture *tex)
{
if (i >= MATERIAL_MAX_TEXTURES)
return;
TextureLayers[i].Texture = tex;
}
//! Inequality operator
/** \param b Material to compare to.
\return True if the materials differ, else false. */
inline bool operator!=(const SMaterial &b) const
{
bool different =
MaterialType != b.MaterialType ||
AmbientColor != b.AmbientColor ||
DiffuseColor != b.DiffuseColor ||
EmissiveColor != b.EmissiveColor ||
SpecularColor != b.SpecularColor ||
Shininess != b.Shininess ||
MaterialTypeParam != b.MaterialTypeParam ||
Thickness != b.Thickness ||
Wireframe != b.Wireframe ||
PointCloud != b.PointCloud ||
GouraudShading != b.GouraudShading ||
Lighting != b.Lighting ||
ZBuffer != b.ZBuffer ||
ZWriteEnable != b.ZWriteEnable ||
BackfaceCulling != b.BackfaceCulling ||
FrontfaceCulling != b.FrontfaceCulling ||
FogEnable != b.FogEnable ||
NormalizeNormals != b.NormalizeNormals ||
AntiAliasing != b.AntiAliasing ||
ColorMask != b.ColorMask ||
ColorMaterial != b.ColorMaterial ||
BlendOperation != b.BlendOperation ||
BlendFactor != b.BlendFactor ||
PolygonOffsetDepthBias != b.PolygonOffsetDepthBias ||
PolygonOffsetSlopeScale != b.PolygonOffsetSlopeScale ||
UseMipMaps != b.UseMipMaps;
for (u32 i = 0; (i < MATERIAL_MAX_TEXTURES) && !different; ++i) {
different |= (TextureLayers[i] != b.TextureLayers[i]);
}
return different;
}
//! Equality operator
/** \param b Material to compare to.
\return True if the materials are equal, else false. */
inline bool operator==(const SMaterial &b) const
{
return !(b != *this);
}
//! Check if material needs alpha blending
bool isAlphaBlendOperation() const
{
if (BlendOperation != EBO_NONE && BlendFactor != 0.f) {
E_BLEND_FACTOR srcRGBFact = EBF_ZERO;
E_BLEND_FACTOR dstRGBFact = EBF_ZERO;
E_BLEND_FACTOR srcAlphaFact = EBF_ZERO;
E_BLEND_FACTOR dstAlphaFact = EBF_ZERO;
E_MODULATE_FUNC modulo = EMFN_MODULATE_1X;
u32 alphaSource = 0;
unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulo, alphaSource, BlendFactor);
if (textureBlendFunc_hasAlpha(srcRGBFact) || textureBlendFunc_hasAlpha(dstRGBFact) ||
textureBlendFunc_hasAlpha(srcAlphaFact) || textureBlendFunc_hasAlpha(dstAlphaFact)) {
return true;
}
}
return false;
}
//! Check for some fixed-function transparent types. Still used internally, but might be deprecated soon.
//! You probably should not use this anymore, IVideoDriver::needsTransparentRenderPass is more useful in most situations
//! as it asks the material renders directly what they do with the material.
bool isTransparent() const
{
if (MaterialType == EMT_TRANSPARENT_ALPHA_CHANNEL ||
MaterialType == EMT_TRANSPARENT_VERTEX_ALPHA)
return true;
return false;
}
};
//! global const identity Material
IRRLICHT_API extern SMaterial IdentityMaterial;
} // end namespace video
} // end namespace irr

Some files were not shown because too many files have changed in this diff Show More