niansa-misc/irrlicht
1
0
Fork 0
mirror of https://github.com/minetest/irrlicht.git synced 2025-03-06 20:49:24 +01:00
Code Issues Projects Releases Packages Wiki Activity

Compare commits

base: niansa-misc:master
Branches Tags
niansa-misc:master
niansa-misc:svn-trunk
niansa-misc:svn-ogl-es
niansa-misc:afl
niansa-misc:bitmapfont
niansa-misc:1.9.0mt15
niansa-misc:1.9.0mt14
niansa-misc:1.9.0mt13
niansa-misc:1.9.0mt12
niansa-misc:1.9.0mt11
niansa-misc:1.9.0mt10
niansa-misc:1.9.0mt9
niansa-misc:1.9.0mt8
niansa-misc:1.9.0mt7
niansa-misc:1.9.0mt6
niansa-misc:1.9.0mt5
niansa-misc:1.9.0mt4
niansa-misc:1.9.0mt3
niansa-misc:1.9.0mt2
niansa-misc:1.9.0mt1
niansa-misc:1.9.0mt0
..
compare: niansa-misc:1.9.0mt8
Branches Tags
niansa-misc:master
niansa-misc:svn-trunk
niansa-misc:svn-ogl-es
niansa-misc:afl
niansa-misc:bitmapfont
niansa-misc:1.9.0mt15
niansa-misc:1.9.0mt14
niansa-misc:1.9.0mt13
niansa-misc:1.9.0mt12
niansa-misc:1.9.0mt11
niansa-misc:1.9.0mt10
niansa-misc:1.9.0mt9
niansa-misc:1.9.0mt8
niansa-misc:1.9.0mt7
niansa-misc:1.9.0mt6
niansa-misc:1.9.0mt5
niansa-misc:1.9.0mt4
niansa-misc:1.9.0mt3
niansa-misc:1.9.0mt2
niansa-misc:1.9.0mt1
niansa-misc:1.9.0mt0

No commits in common. "master" and "1.9.0mt8" have entirely different histories.
master ... 1.9.0mt8

498 changed files with 121375 additions and 103853 deletions
Show stats Expand all files Collapse all files

2
.editorconfig
View file

@ -1,5 +1,3 @@
root = true
[*]
charset = utf-8

235
.github/workflows/build.yml vendored
View file

@ -8,9 +8,9 @@ on:
jobs:
linux-gl:
runs-on: ubuntu-20.04
runs-on: ubuntu-18.04
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@v2
- name: Install deps
run: |
sudo apt-get update
@ -18,28 +18,23 @@ jobs:
- name: Build
run: |
cmake . -DUSE_SDL2=OFF
cmake .
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
- uses: actions/upload-artifact@v2
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
runs-on: ubuntu-18.04
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@v2
- name: Install deps
run: |
sudo apt-get update
@ -47,7 +42,9 @@ jobs:
- name: Build
run: |
cmake . -DBUILD_EXAMPLES=1 -DUSE_SDL2=OFF -DENABLE_OPENGL=OFF -DENABLE_GLES2=ON
sed '/#define _IRR_COMPILE_WITH_OGLES2_/ s|^//||g' -i include/IrrCompileConfig.h
sed '/#define _IRR_COMPILE_WITH_OPENGL_/ s|^|//|g' -i include/IrrCompileConfig.h
cmake . -DBUILD_EXAMPLES=1
make -j2
- name: Test (headless)
@ -58,118 +55,60 @@ jobs:
- name: Test (Xvfb)
run: |
cd bin/Linux
LIBGL_ALWAYS_SOFTWARE=true xvfb-run ./AutomatedTest ogles2
LIBGL_ALWAYS_SOFTWARE=true xvfb-run ./AutomatedTest
linux-sdl:
win32:
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
- uses: actions/checkout@v2
- name: Install compiler
run: |
sudo apt-get update && sudo apt-get install cmake -qyy
./scripts/ci-get-mingw.sh
wget http://minetest.kitsunemimi.pw/mingw-w64-i686_11.2.0_ubuntu20.04.tar.xz -O mingw.tar.xz
sudo tar -xaf mingw.tar.xz -C /usr
- 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}}
CC: i686-w64-mingw32-gcc
CXX: i686-w64-mingw32-g++
- uses: actions/upload-artifact@v4
- uses: actions/upload-artifact@v2
with:
name: irrlicht-${{matrix.config.variant}}${{matrix.config.extras}}
path: ./irrlicht-${{matrix.config.variant}}${{matrix.config.extras}}.zip
name: irrlicht-win32
path: ./irrlicht-win32.zip
win64:
runs-on: ubuntu-20.04
steps:
- uses: actions/checkout@v2
- name: Install compiler
run: |
sudo apt-get update && sudo apt-get install cmake -qyy
wget http://minetest.kitsunemimi.pw/mingw-w64-x86_64_11.2.0_ubuntu20.04.tar.xz -O mingw.tar.xz
sudo tar -xaf mingw.tar.xz -C /usr
- name: Build
run: |
./scripts/ci-build-mingw.sh package
env:
CC: x86_64-w64-mingw32-gcc
CXX: x86_64-w64-mingw32-g++
- uses: actions/upload-artifact@v2
with:
name: irrlicht-win64
path: ./irrlicht-win64.zip
macos:
runs-on: macos-latest
runs-on: macos-10.15
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@v2
- name: Install deps
run: |
brew update --auto-update
brew update
brew install cmake libpng jpeg
env:
HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
HOMEBREW_NO_INSTALL_CLEANUP: 1
- name: Build
run: |
@ -180,30 +119,13 @@ jobs:
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 }}
name: VS 2019 ${{ matrix.config.arch }}
runs-on: windows-2019
env:
VCPKG_VERSION: 8eb57355a4ffb410a2e94c07b4dca2dffbee8e50
# 2023.10.19
vcpkg_packages: zlib libpng libjpeg-turbo
VCPKG_VERSION: 14e7bb4ae24616ec54ff6b2f6ef4e8659434ea44
# 2022.05.10
vcpkg_packages: zlib libpng libjpeg-turbo opengl-registry
strategy:
fail-fast: false
matrix:
@ -216,24 +138,15 @@ jobs:
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
uses: actions/checkout@v3
- name: Restore from cache and run vcpkg
uses: lukka/run-vcpkg@v7
with:
vcpkgArguments: ${{env.vcpkg_packages}} ${{matrix.sdl.vcpkg_packages}}
vcpkgArguments: ${{env.vcpkg_packages}}
vcpkgDirectory: '${{ github.workspace }}\vcpkg'
appendedCacheKey: ${{ matrix.config.vcpkg_triplet }}
vcpkgGitCommitId: ${{ env.VCPKG_VERSION }}
@ -242,7 +155,6 @@ jobs:
- 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 .
@ -261,50 +173,7 @@ jobs:
run: move include artifact/
- name: Upload Artifact
uses: actions/upload-artifact@v4
uses: actions/upload-artifact@v2
with:
name: msvc-${{ matrix.config.arch }}-${{matrix.sdl.use}}
name: msvc-${{ matrix.config.arch }}
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 }}

4
.gitignore vendored
View file

@ -5,7 +5,6 @@ install_manifest.txt
IrrlichtMtConfig.cmake
IrrlichtMtConfigVersion.cmake
IrrlichtMtTargets.cmake
CTestTestfile.cmake
Makefile
libs/*
*.so*
@ -20,6 +19,3 @@ scripts/glext.h
*.dir/
*.sln
*visualstudio/
# vscode cmake plugin
build/*

18
CMakeLists.txt
View file

@ -1,6 +1,13 @@
cmake_minimum_required(VERSION 3.12)
cmake_minimum_required(VERSION 3.5)
set(IRRLICHTMT_REVISION 15)
# Set policies up to 3.9 since we want to enable the IPO option
if(${CMAKE_VERSION} VERSION_LESS 3.9)
cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
else()
cmake_policy(VERSION 3.9)
endif()
set(IRRLICHTMT_REVISION 8)
project(Irrlicht
VERSION 1.9.0.${IRRLICHTMT_REVISION}
@ -9,9 +16,6 @@ project(Irrlicht
message(STATUS "*** Building IrrlichtMt ${PROJECT_VERSION} ***")
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
include(GNUInstallDirs)
if(ANDROID)
@ -34,9 +38,7 @@ if(NOT CMAKE_BUILD_TYPE)
endif()
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
enable_testing()
add_subdirectory(src)
add_subdirectory(test)
add_subdirectory(source/Irrlicht)
option(BUILD_EXAMPLES "Build example applications" FALSE)
if(BUILD_EXAMPLES)

6
Config.cmake.in
View file

@ -1,11 +1,5 @@
@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()

32
README.md
View file

@ -1,16 +1,9 @@
IrrlichtMt version 1.9
======================
Notice
------
The Irrlicht Engine is an open source realtime 3D engine written in C++.
IrrlichtMt has been moved into the [main Minetest repository](https://github.com/minetest) during Minetest 5.9 development. This repository is an archive useful for building older versions of Minetest.
About
-----
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.
This is a fork by the [Minetest](https://github.com/minetest) developers that was stripped-down and customized specifically for use in Minetest.
It is intentionally not compatible to upstream and is planned to be eventually absorbed into Minetest.
Build
@ -23,16 +16,10 @@ The following libraries are required to be installed:
* 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:
@ -43,21 +30,6 @@ e.g. on a Linux system you might want to build for local use like this:
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
---------

4
bin/Linux/readme.txt Normal file
View file

@ -0,0 +1,4 @@
If you wish to compile the engine in linux yourself,
goto the \source directory. Run a 'make' in the subfolder 'Irrlicht'.
After this, you should be able to make all example applications in \examples.
Then just start an X Server and run them, from the directory where they are.

1
bin/OSX/readme.txt Normal file
View file

@ -0,0 +1 @@
If you want to compile only the Irrlicht Engine you should use XCode project available at source/Irrlicht/ directory. You can also use examples/BuildAllExamples.xcworkspace file to build the Irrlicht Engine + all examples.

BIN
bin/Win32-VisualStudio/irrlicht.ico Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.2 KiB

25
bin/Win32-VisualStudio/readme.txt Normal file
View file

@ -0,0 +1,25 @@
The Win32-VisualStudio version is currently (Irrlicht 1.8) compiled with VS 2010 using the Windows 7.1 SDK as platform toolset.
You might get the necessary Windows Platform SDK here: http://msdn.microsoft.com/en-us/windows/bb980924.aspx
To link to that Irrlicht.dll you need to set platform toolset in your VS version to the same target or re-compile the Irrlicht.dll using another platform toolset.
To re-compile Irrlicht for Win32-VisualStudio:
There are several project files for different VS versions in source/Irrlicht.
Irrlicht10.0.sln is for VS 2010
Irrlicht11.0.sln is for VS 2012
Irrlicht12.0.sln is for VS 2013
To compile Irrlicht + all examples and all tools check the BuildAllExamples_*.sln files in the examples folder.
For newer VS versions you have update one of those projects (VS usually can do that automatically when you open an older solution file).
Currently each of those solutions does set the platform toolset "Windows 7.1 SDK" (to be compatible to each other).
You might want to change that in the project settings and set it to your current version.
Make sure you use the same platform toolset in your application and in the engine.
Also when compiling examples each example has to use the same platform toolset as was used for the engine.
Platform should be Win32
Configuration is by default "Release"
But you can also chose "Debug" if you want Irrlicht with Debug information.
Static builds are possible but you have to additionally set the _IRR_STATIC_LIB_ define in the application when linking to a static Irrlicht.lib

BIN
bin/Win32-gcc/irrlicht.ico Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.2 KiB

16
bin/Win32-gcc/readme.txt Normal file
View file

@ -0,0 +1,16 @@
If you wish to compile Irrlicht for Win32-gcc you have several choices.
1. You can work from within a MinGW shell.
Go to the folder source/Irrlicht and run the Makefile with:
make win32
Examples can be build by going into the folder of the example (for example examples/01.HelloWorld) and running the Makefile with:
make all_win32
2. Use the Code::Blocks IDE
There is a project file called Irrlicht-gcc.cbp in source/Irrlicht to compile just the engine.
Be sure to select a Windows target like "Win32 - release - accurate math - dll"
There is also Code::Blocks workspace file in the examples folder called BuildAllExamples.workspace
Again be sure to select a Windows target like "Win32 - release - accurate math - dll"
This workspace allows you to compile the engine together with all examples and tools.

1
bin/emscripten/readme.txt Normal file
View file

@ -0,0 +1 @@
If you wish to compile Irrlicht for emscripten please check the documenation in examples/01.HelloWorld_emscripten.

5527
changes.txt Normal file
View file

File diff suppressed because it is too large Load diff

0
LICENSE → doc/irrlicht-license.txt
View file

63
doc/release_checklist.txt Normal file
View file

@ -0,0 +1,63 @@
Checklist for Irrlicht developers doing releases.
Note: Generally the more platforms, compilers, settings you can test the better. Ask for help for platforms which you don't own.
- PRE-BUILD TESTS:
- - Run tests in the tests folder
- - Compile and run examples.
- - Compile and run the tools. Note that some tools are in the buildall-examples VS project files on Windows,
but on Linux command line you have to compile them individually.
- VERSION UPDATES:
- - check IRRLICHT_SDK_VERSION (in IrrCompileConfig.h)
- - check version number in the Makefile
- - update readme.txt (version number, supported compilers)
- - Add new release information (date+version-number) in changes.txt
- - go through folders if other .txt files still make sense (things change and updating those files tends to be forgotten)
- DOCUMENTATION UPDATES:
- - run makedocumentation.sh in scripts\doc\irrlicht
- - run maketutorial.sh in scripts\doc\irrlicht (commit changed tutorial.html's)
- BUILDING THE RELEASE
(TBD - should we still release dll's? Newer and older VS builds are no longer compatible anyway)
- - run a clean build for buildAllExamples in the examples folder with the
target compiler for 32-bit and for release (old VS compiler - so far VS2010)
- - when possible compile the dll for MinGW on Windows (in release and with -s for smaller size)
- - when possible compile the dll for 64 bit (again with Visual Studio and release)
- - create a target directory, like irrlicht-1.8.1 for example
- - svn export to the target directory
- - copy the subfolders of doctemp into the doc folder of the target directory
careful, this should only be one(!) subfolder (we ended up with copies before, maybe Windows/Linux builds use different names?)
- - copy all .exe files (except test.exe) from bin\Win32-VisualStudio (.pdb's are not necessary)
- - copy Irrlicht.dll from bin\Win32-visualstudio
- - copy the files in lib\Win32-visualstudio
- - copy Irrlicht.dll from bin\Win64-VisualStudio
- - copy the files in lib\Win64-visualstudio
- - copy Irrlicht.dll from bin\Win32-gcc
- - copy the files in lib\Win32-gcc
- - remove the tests folder
- - remove scripts folder (if the release comes with docs, if you do a release
without docs for smaller filesizes then the script folder has to stay in).
- - create a zip file
- - figure out how to fix unix access right for shell-scripts in the zip file (my
trick so far is: unzip in Linux, set +x for all .sh files, zip again)
RELEASING:
- - upload the zip-file somewhere, then download it again on all platforms and do
another quick test with that file (do examples still run, can you compile)
- - give the link to the zip out on the mailinglist for others to look at
- - Upload new documentation (the content of doc/html) to: web.sourceforge.net
(sftp protocol, user and passwd are your sourceforge account, the folder
might not be shown - but you can still cd into it!):
/home/project-web/i/ir/irrlicht/htdocs
Best create first a folder with a new name, copy stuff in there, test (just
check the website), rename old folder and give new folder the "docu" name.
Then you can delete the old folder if you want.
- - upload the zip by logging in to sourceforge and using the "Files" menu (needs
admin privileges and it's the 'Files' menu between 'Summary' and 'Reviews').
The target is in one of the Irrlicht SDK subfolders. Then click the "i" beside
the file and "select all" to make it the active download.
- - write a forum post, tell everyone in facebook, reddit, your friends...
- - login to wordpress at http://irrlicht.sourceforge.net/wp-login.php, update the
downloads section and write a release post.

2891
doc/upgrade-guide.txt Normal file
View file

File diff suppressed because it is too large Load diff

66
examples/AutomatedTest/main.cpp
View file

@ -7,44 +7,32 @@ using namespace irr;
static IrrlichtDevice *device = nullptr;
static int test_fail = 0;
void test_irr_array();
void test_irr_string();
extern void test_irr_array();
static video::E_DRIVER_TYPE chooseDriver(core::stringc arg_)
static video::E_DRIVER_TYPE chooseDriver(const char *arg_)
{
if (arg_ == "null")
if (core::stringc(arg_) == "null")
return video::EDT_NULL;
if (arg_ == "ogles1")
if (IrrlichtDevice::isDriverSupported(video::EDT_OGLES1))
return video::EDT_OGLES1;
if (arg_ == "ogles2")
if (IrrlichtDevice::isDriverSupported(video::EDT_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) {
if (!ok)
{
test_fail++;
device->getLogger()->log((core::stringc("FAILED TEST: ") + msg).c_str(), ELL_ERROR);
}
}
void run_unit_tests()
{
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[])
@ -87,23 +75,19 @@ int main(int argc, char *argv[])
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);
scene::IAnimatedMesh* mesh = smgr->getMesh(mediaPath + "coolguy_opt.x");
check(mesh, "mesh loading");
if (mesh_file)
mesh_file->drop();
if (mesh) {
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);
});
if (node)
{
node->setMaterialFlag(video::EMF_LIGHTING, false);
node->setFrameLoop(0, 29);
node->setAnimationSpeed(30);
node->setMaterialTexture(0, tex);
}
}
@ -113,20 +97,25 @@ int main(int argc, char *argv[])
SEvent event;
device->getTimer()->start();
while (device->run()) {
if (device->getTimer()->getTime() >= 1000) {
while (device->run())
{
if (device->getTimer()->getTime() >= 1300)
{
device->getTimer()->setTime(0);
++n;
if (n == 1) { // Tooltip display
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
}
else if (n == 2) // Text input focus
guienv->setFocus(editbox);
else if (n == 3) { // Keypress for Text input
else if (n == 3) // Keypress for Text input
{
bzero(&event, sizeof(SEvent));
event.EventType = irr::EET_KEY_INPUT_EVENT;
event.KeyInput.Char = L'a';
@ -135,7 +124,8 @@ int main(int argc, char *argv[])
device->postEventFromUser(event);
event.KeyInput.PressedDown = false;
device->postEventFromUser(event);
} else
}
else
device->closeDevice();
}

11
examples/AutomatedTest/test_array.cpp
View file

@ -1,11 +1,10 @@
#include <irrArray.h>
#include "irrArray.h"
#include "test_helper.h"
using namespace irr;
using core::array;
static void test_basics()
{
static void test_basics() {
array<int> v;
v.push_back(1); // 1
v.push_front(2); // 2, 1
@ -58,8 +57,7 @@ static void test_basics()
UASSERTEQ(v.size(), 2);
}
static void test_linear_searches()
{
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++)
@ -77,8 +75,7 @@ static void test_linear_searches()
}
}
static void test_binary_searches()
{
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) {

9
examples/AutomatedTest/test_helper.h
View file

@ -3,13 +3,11 @@
#include <exception>
#include <iostream>
class TestFailedException : public std::exception
{
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 { \
#define UASSERTCMP(CMP, actual, expected) do { \
const auto &a = (actual); \
const auto &e = (expected); \
if (!CMP(a, e)) { \
@ -17,8 +15,7 @@ class TestFailedException : public std::exception
<< "Test assertion failed: " << #actual << " " << #CMP << " " \
<< #expected << std::endl \
<< " at " << __FILE__ << ":" << __LINE__ << std::endl \
<< " actual: " << a << std::endl \
<< " expected: " \
<< " actual: " << a << std::endl << " expected: " \
<< e << std::endl; \
throw TestFailedException(); \
} \

205
examples/AutomatedTest/test_string.cpp
View file

@ -1,205 +0,0 @@
#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;
}

3
examples/CMakeLists.txt
View file

@ -1,3 +1,6 @@
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(IRREXAMPLES
# removed
)

226
include/CIndexBuffer.h Normal file
View file

@ -0,0 +1,226 @@
// 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
#ifndef __C_INDEX_BUFFER_H_INCLUDED__
#define __C_INDEX_BUFFER_H_INCLUDED__
#include "IIndexBuffer.h"
namespace irr
{
namespace scene
{
class CIndexBuffer : public IIndexBuffer
{
class IIndexList
{
public:
virtual ~IIndexList(){};
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;
virtual video::E_INDEX_TYPE getType() const =0;
};
template <class T>
class CSpecificIndexList : public IIndexList
{
public:
core::array<T> Indices;
virtual u32 stride() const _IRR_OVERRIDE_ {return sizeof(T);}
virtual u32 size() const _IRR_OVERRIDE_ {return Indices.size();}
virtual void push_back(const u32 &element) _IRR_OVERRIDE_
{
// push const ref due to compiler problem with gcc 4.6, big endian
Indices.push_back((const T&)element);
}
virtual u32 operator [](u32 index) const _IRR_OVERRIDE_
{
return (u32)(Indices[index]);
}
virtual u32 getLast() _IRR_OVERRIDE_ {return (u32)Indices.getLast();}
virtual void setValue(u32 index, u32 value) _IRR_OVERRIDE_
{
Indices[index]=(T)value;
}
virtual void set_used(u32 usedNow) _IRR_OVERRIDE_
{
Indices.set_used(usedNow);
}
virtual void reallocate(u32 new_size) _IRR_OVERRIDE_
{
Indices.reallocate(new_size);
}
virtual u32 allocated_size() const _IRR_OVERRIDE_
{
return Indices.allocated_size();
}
virtual void* pointer() _IRR_OVERRIDE_ {return Indices.pointer();}
virtual video::E_INDEX_TYPE getType() const _IRR_OVERRIDE_
{
if (sizeof(T)==sizeof(u16))
return video::EIT_16BIT;
else
return video::EIT_32BIT;
}
};
public:
IIndexList *Indices;
CIndexBuffer(video::E_INDEX_TYPE IndexType) :Indices(0), MappingHint(EHM_NEVER), ChangedID(1)
{
setType(IndexType);
}
CIndexBuffer(const IIndexBuffer &IndexBufferCopy) :Indices(0), MappingHint(EHM_NEVER), ChangedID(1)
{
setType(IndexBufferCopy.getType());
reallocate(IndexBufferCopy.size());
for (u32 n=0;n<IndexBufferCopy.size();++n)
push_back(IndexBufferCopy[n]);
}
virtual ~CIndexBuffer()
{
delete Indices;
}
//virtual void setType(video::E_INDEX_TYPE IndexType);
virtual void setType(video::E_INDEX_TYPE IndexType) _IRR_OVERRIDE_
{
IIndexList *NewIndices=0;
switch (IndexType)
{
case video::EIT_16BIT:
{
NewIndices=new CSpecificIndexList<u16>;
break;
}
case video::EIT_32BIT:
{
NewIndices=new CSpecificIndexList<u32>;
break;
}
}
if (Indices)
{
NewIndices->reallocate( Indices->size() );
for(u32 n=0;n<Indices->size();++n)
NewIndices->push_back((*Indices)[n]);
delete Indices;
}
Indices=NewIndices;
}
virtual void* getData() _IRR_OVERRIDE_ {return Indices->pointer();}
virtual video::E_INDEX_TYPE getType() const _IRR_OVERRIDE_ {return Indices->getType();}
virtual u32 stride() const _IRR_OVERRIDE_ {return Indices->stride();}
virtual u32 size() const _IRR_OVERRIDE_
{
return Indices->size();
}
virtual void push_back(const u32 &element) _IRR_OVERRIDE_
{
Indices->push_back(element);
}
virtual u32 operator [](u32 index) const _IRR_OVERRIDE_
{
return (*Indices)[index];
}
virtual u32 getLast() _IRR_OVERRIDE_
{
return Indices->getLast();
}
virtual void setValue(u32 index, u32 value) _IRR_OVERRIDE_
{
Indices->setValue(index, value);
}
virtual void set_used(u32 usedNow) _IRR_OVERRIDE_
{
Indices->set_used(usedNow);
}
virtual void reallocate(u32 new_size) _IRR_OVERRIDE_
{
Indices->reallocate(new_size);
}
virtual u32 allocated_size() const _IRR_OVERRIDE_
{
return Indices->allocated_size();
}
virtual void* pointer() _IRR_OVERRIDE_
{
return Indices->pointer();
}
//! get the current hardware mapping hint
virtual E_HARDWARE_MAPPING getHardwareMappingHint() const _IRR_OVERRIDE_
{
return MappingHint;
}
//! set the hardware mapping hint, for driver
virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) _IRR_OVERRIDE_
{
MappingHint=NewMappingHint;
}
//! flags the mesh as changed, reloads hardware buffers
virtual void setDirty() _IRR_OVERRIDE_
{
++ChangedID;
}
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
virtual u32 getChangedID() const _IRR_OVERRIDE_ {return ChangedID;}
E_HARDWARE_MAPPING MappingHint;
u32 ChangedID;
};
} // end namespace scene
} // end namespace irr
#endif

136
include/CMeshBuffer.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __T_MESH_BUFFER_H_INCLUDED__
#define __T_MESH_BUFFER_H_INCLUDED__
#include "irrArray.h"
#include "IMeshBuffer.h"
@ -17,154 +18,172 @@ 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)
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
virtual const video::SMaterial& getMaterial() const _IRR_OVERRIDE_
{
return Material;
}
//! Get material of this meshbuffer
/** \return Material of this buffer */
video::SMaterial &getMaterial() override
virtual video::SMaterial& getMaterial() _IRR_OVERRIDE_
{
return Material;
}
//! Get pointer to vertices
/** \return Pointer to vertices. */
const void *getVertices() const override
virtual const void* getVertices() const _IRR_OVERRIDE_
{
return Vertices.const_pointer();
}
//! Get pointer to vertices
/** \return Pointer to vertices. */
void *getVertices() override
virtual void* getVertices() _IRR_OVERRIDE_
{
return Vertices.pointer();
}
//! Get number of vertices
/** \return Number of vertices. */
u32 getVertexCount() const override
virtual u32 getVertexCount() const _IRR_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
virtual video::E_INDEX_TYPE getIndexType() const _IRR_OVERRIDE_
{
return video::EIT_16BIT;
}
//! Get pointer to indices
/** \return Pointer to indices. */
const u16 *getIndices() const override
virtual const u16* getIndices() const _IRR_OVERRIDE_
{
return Indices.const_pointer();
}
//! Get pointer to indices
/** \return Pointer to indices. */
u16 *getIndices() override
virtual u16* getIndices() _IRR_OVERRIDE_
{
return Indices.pointer();
}
//! Get number of indices
/** \return Number of indices. */
u32 getIndexCount() const override
virtual u32 getIndexCount() const _IRR_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
virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_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
virtual void setBoundingBox(const core::aabbox3df& box) _IRR_OVERRIDE_
{
BoundingBox = box;
}
//! Recalculate the bounding box.
/** should be called if the mesh changed. */
void recalculateBoundingBox() override
virtual void recalculateBoundingBox() _IRR_OVERRIDE_
{
if (!Vertices.empty())
{
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);
}
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
virtual video::E_VERTEX_TYPE getVertexType() const _IRR_OVERRIDE_
{
return T::getType();
}
//! returns position of vertex i
const core::vector3df &getPosition(u32 i) const override
virtual const core::vector3df& getPosition(u32 i) const _IRR_OVERRIDE_
{
return Vertices[i].Pos;
}
//! returns position of vertex i
core::vector3df &getPosition(u32 i) override
virtual core::vector3df& getPosition(u32 i) _IRR_OVERRIDE_
{
return Vertices[i].Pos;
}
//! returns normal of vertex i
const core::vector3df &getNormal(u32 i) const override
virtual const core::vector3df& getNormal(u32 i) const _IRR_OVERRIDE_
{
return Vertices[i].Normal;
}
//! returns normal of vertex i
core::vector3df &getNormal(u32 i) override
virtual core::vector3df& getNormal(u32 i) _IRR_OVERRIDE_
{
return Vertices[i].Normal;
}
//! returns texture coord of vertex i
const core::vector2df &getTCoords(u32 i) const override
virtual const core::vector2df& getTCoords(u32 i) const _IRR_OVERRIDE_
{
return Vertices[i].TCoords;
}
//! returns texture coord of vertex i
core::vector2df &getTCoords(u32 i) override
virtual core::vector2df& getTCoords(u32 i) _IRR_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
virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) _IRR_OVERRIDE_
{
if (vertices == getVertices())
return;
@ -173,31 +192,65 @@ public:
u32 i;
Vertices.reallocate(vertexCount+numVertices);
for (i = 0; i < numVertices; ++i) {
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) {
for (i=0; i<numIndices; ++i)
{
Indices.push_back(indices[i]+vertexCount);
}
}
//! Append the meshbuffer 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.
\param other Meshbuffer to be appended to this one.
*/
virtual void append(const IMeshBuffer* const other) _IRR_OVERRIDE_
{
/*
if (this==other)
return;
const u32 vertexCount = getVertexCount();
u32 i;
Vertices.reallocate(vertexCount+other->getVertexCount());
for (i=0; i<other->getVertexCount(); ++i)
{
Vertices.push_back(reinterpret_cast<const T*>(other->getVertices())[i]);
}
Indices.reallocate(getIndexCount()+other->getIndexCount());
for (i=0; i<other->getIndexCount(); ++i)
{
Indices.push_back(other->getIndices()[i]+vertexCount);
}
BoundingBox.addInternalBox(other->getBoundingBox());
*/
}
//! get the current hardware mapping hint
E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const override
virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const _IRR_OVERRIDE_
{
return MappingHint_Vertex;
}
//! get the current hardware mapping hint
E_HARDWARE_MAPPING getHardwareMappingHint_Index() const override
virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const _IRR_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
virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX ) _IRR_OVERRIDE_
{
if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_VERTEX)
MappingHint_Vertex=NewMappingHint;
@ -206,19 +259,19 @@ public:
}
//! Describe what kind of primitive geometry is used by the meshbuffer
void setPrimitiveType(E_PRIMITIVE_TYPE type) override
virtual void setPrimitiveType(E_PRIMITIVE_TYPE type) _IRR_OVERRIDE_
{
PrimitiveType = type;
}
//! Get the kind of primitive geometry which is used by the meshbuffer
E_PRIMITIVE_TYPE getPrimitiveType() const override
virtual E_PRIMITIVE_TYPE getPrimitiveType() const _IRR_OVERRIDE_
{
return PrimitiveType;
}
//! flags the mesh as changed, reloads hardware buffers
void setDirty(E_BUFFER_TYPE Buffer = EBT_VERTEX_AND_INDEX) override
virtual void setDirty(E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX) _IRR_OVERRIDE_
{
if (Buffer==EBT_VERTEX_AND_INDEX ||Buffer==EBT_VERTEX)
++ChangedID_Vertex;
@ -228,22 +281,21 @@ public:
//! 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; }
virtual u32 getChangedID_Vertex() const _IRR_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; }
virtual u32 getChangedID_Index() const _IRR_OVERRIDE_ {return ChangedID_Index;}
void setHWBuffer(void *ptr) const override
{
virtual void setHWBuffer(void *ptr) const _IRR_OVERRIDE_ {
HWBuffer = ptr;
}
void *getHWBuffer() const override
{
virtual void *getHWBuffer() const _IRR_OVERRIDE_ {
return HWBuffer;
}
u32 ChangedID_Vertex;
u32 ChangedID_Index;
@ -272,3 +324,7 @@ typedef CMeshBuffer<video::S3DVertex2TCoords> SMeshBufferLightMap;
typedef CMeshBuffer<video::S3DVertexTangents> SMeshBufferTangents;
} // end namespace scene
} // end namespace irr
#endif

210
include/CVertexBuffer.h Normal file
View file

@ -0,0 +1,210 @@
// 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
#ifndef __C_VERTEX_BUFFER_H_INCLUDED__
#define __C_VERTEX_BUFFER_H_INCLUDED__
#include "IVertexBuffer.h"
namespace irr
{
namespace scene
{
class CVertexBuffer : public IVertexBuffer
{
class IVertexList
{
public:
virtual ~IVertexList(){};
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;
virtual video::E_VERTEX_TYPE getType() const =0;
};
template <class T>
class CSpecificVertexList : public IVertexList
{
public:
core::array<T> Vertices;
virtual u32 stride() const _IRR_OVERRIDE_ {return sizeof(T);}
virtual u32 size() const _IRR_OVERRIDE_ {return Vertices.size();}
virtual void push_back (const video::S3DVertex &element) _IRR_OVERRIDE_
{Vertices.push_back((T&)element);}
virtual video::S3DVertex& operator [](const u32 index) const _IRR_OVERRIDE_
{return (video::S3DVertex&)Vertices[index];}
virtual video::S3DVertex& getLast() _IRR_OVERRIDE_
{return (video::S3DVertex&)Vertices.getLast();}
virtual void set_used(u32 usedNow) _IRR_OVERRIDE_
{Vertices.set_used(usedNow);}
virtual void reallocate(u32 new_size) _IRR_OVERRIDE_
{Vertices.reallocate(new_size);}
virtual u32 allocated_size() const _IRR_OVERRIDE_
{
return Vertices.allocated_size();
}
virtual video::S3DVertex* pointer() _IRR_OVERRIDE_ {return Vertices.pointer();}
virtual video::E_VERTEX_TYPE getType() const _IRR_OVERRIDE_ {return T::getType();}
};
public:
IVertexList *Vertices;
CVertexBuffer(video::E_VERTEX_TYPE vertexType) : Vertices(0),
MappingHint(EHM_NEVER), ChangedID(1)
{
setType(vertexType);
}
CVertexBuffer(const IVertexBuffer &VertexBufferCopy) :
Vertices(0), MappingHint(EHM_NEVER),
ChangedID(1)
{
setType(VertexBufferCopy.getType());
reallocate(VertexBufferCopy.size());
for (u32 n=0;n<VertexBufferCopy.size();++n)
push_back(VertexBufferCopy[n]);
}
virtual ~CVertexBuffer()
{
delete Vertices;
}
virtual void setType(video::E_VERTEX_TYPE vertexType) _IRR_OVERRIDE_
{
IVertexList *NewVertices=0;
switch (vertexType)
{
case video::EVT_STANDARD:
{
NewVertices=new CSpecificVertexList<video::S3DVertex>;
break;
}
case video::EVT_2TCOORDS:
{
NewVertices=new CSpecificVertexList<video::S3DVertex2TCoords>;
break;
}
case video::EVT_TANGENTS:
{
NewVertices=new CSpecificVertexList<video::S3DVertexTangents>;
break;
}
}
if (Vertices)
{
NewVertices->reallocate( Vertices->size() );
for(u32 n=0;n<Vertices->size();++n)
NewVertices->push_back((*Vertices)[n]);
delete Vertices;
}
Vertices=NewVertices;
}
virtual void* getData() _IRR_OVERRIDE_ {return Vertices->pointer();}
virtual video::E_VERTEX_TYPE getType() const _IRR_OVERRIDE_ {return Vertices->getType();}
virtual u32 stride() const _IRR_OVERRIDE_ {return Vertices->stride();}
virtual u32 size() const _IRR_OVERRIDE_
{
return Vertices->size();
}
virtual void push_back (const video::S3DVertex &element) _IRR_OVERRIDE_
{
Vertices->push_back(element);
}
virtual video::S3DVertex& operator [](const u32 index) const _IRR_OVERRIDE_
{
return (*Vertices)[index];
}
virtual video::S3DVertex& getLast() _IRR_OVERRIDE_
{
return Vertices->getLast();
}
virtual void set_used(u32 usedNow) _IRR_OVERRIDE_
{
Vertices->set_used(usedNow);
}
virtual void reallocate(u32 new_size) _IRR_OVERRIDE_
{
Vertices->reallocate(new_size);
}
virtual u32 allocated_size() const _IRR_OVERRIDE_
{
return Vertices->allocated_size();
}
virtual video::S3DVertex* pointer() _IRR_OVERRIDE_
{
return Vertices->pointer();
}
//! get the current hardware mapping hint
virtual E_HARDWARE_MAPPING getHardwareMappingHint() const _IRR_OVERRIDE_
{
return MappingHint;
}
//! set the hardware mapping hint, for driver
virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) _IRR_OVERRIDE_
{
MappingHint=NewMappingHint;
}
//! flags the mesh as changed, reloads hardware buffers
virtual void setDirty() _IRR_OVERRIDE_
{
++ChangedID;
}
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
virtual u32 getChangedID() const _IRR_OVERRIDE_ {return ChangedID;}
E_HARDWARE_MAPPING MappingHint;
u32 ChangedID;
};
} // end namespace scene
} // end namespace irr
#endif

71
include/EAttributes.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_ATTRIBUTES_H_INCLUDED__
#define __E_ATTRIBUTES_H_INCLUDED__
namespace irr
{
@ -18,9 +19,75 @@ enum E_ATTRIBUTE_TYPE
// float attribute
EAT_FLOAT,
// string attribute
EAT_STRING,
// boolean attribute
EAT_BOOL,
// enumeration attribute
EAT_ENUM,
// color attribute
EAT_COLOR,
// floating point color attribute
EAT_COLORF,
// 3d vector attribute
EAT_VECTOR3D,
// 2d position attribute
EAT_POSITION2D,
// vector 2d attribute
EAT_VECTOR2D,
// rectangle attribute
EAT_RECT,
// matrix attribute
EAT_MATRIX,
// quaternion attribute
EAT_QUATERNION,
// 3d bounding box
EAT_BBOX,
// plane
EAT_PLANE,
// 3d triangle
EAT_TRIANGLE3D,
// line 2d
EAT_LINE2D,
// line 3d
EAT_LINE3D,
// array of stringws attribute
EAT_STRINGWARRAY,
// array of float
EAT_FLOATARRAY,
// array of int
EAT_INTARRAY,
// binary data attribute
EAT_BINARY,
// texture reference attribute
EAT_TEXTURE,
// user pointer void*
EAT_USER_POINTER,
// dimension attribute
EAT_DIMENSION2D,
// known attribute type count
EAT_COUNT,
@ -30,3 +97,5 @@ enum E_ATTRIBUTE_TYPE
} // end namespace io
} // end namespace irr
#endif

12
include/ECullingTypes.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_CULLING_TYPES_H_INCLUDED__
#define __E_CULLING_TYPES_H_INCLUDED__
#include "irrTypes.h"
@ -22,14 +23,19 @@ enum E_CULLING_TYPE
};
//! Names for culling type
const c8 *const AutomaticCullingNames[] = {
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,
0
};
} // end namespace scene
} // end namespace irr
#endif // __E_CULLING_TYPES_H_INCLUDED__

11
include/EDebugSceneTypes.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_DEBUG_SCENE_TYPES_H_INCLUDED__
#define __E_DEBUG_SCENE_TYPES_H_INCLUDED__
namespace irr
{
@ -27,6 +28,9 @@ enum E_DEBUG_SCENE_TYPE
//! Overlays Mesh Wireframe
EDS_MESH_WIRE_OVERLAY = 8,
//! Temporary use transparency Material Type
EDS_HALF_TRANSPARENCY = 16,
//! Show Bounding Boxes of all MeshBuffers
EDS_BBOX_BUFFERS = 32,
@ -37,5 +41,10 @@ enum E_DEBUG_SCENE_TYPE
EDS_FULL = 0xffffffff
};
} // end namespace scene
} // end namespace irr
#endif // __E_DEBUG_SCENE_TYPES_H_INCLUDED__

12
include/EDeviceTypes.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_DEVICE_TYPES_H_INCLUDED__
#define __E_DEVICE_TYPES_H_INCLUDED__
namespace irr
{
@ -24,9 +25,13 @@ enum E_DEVICE_TYPE
/** This device uses Apple's Cocoa API and works in Mac OSX 10.2 and above. */
EIDT_OSX,
//! A device native to the iOS
/** This device should be used with the OpenGL-ES driver. */
EIDT_IOS,
//! 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 */
in by defining the _IRR_COMPILE_WITH_SDL_DEVICE_ macro in IrrCompileConfig.h */
EIDT_SDL,
//! This selection allows Irrlicht to choose the best device from the ones available.
@ -44,3 +49,6 @@ enum E_DEVICE_TYPE
};
} // end namespace irr
#endif // __E_DEVICE_TYPES_H_INCLUDED__

22
include/EDriverFeatures.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_DRIVER_FEATURES_H_INCLUDED__
#define __E_DRIVER_FEATURES_H_INCLUDED__
namespace irr
{
@ -120,6 +121,21 @@ enum E_VIDEO_DRIVER_FEATURE
//! Support for texture coord transformation via texture matrix
EVDF_TEXTURE_MATRIX,
//! Support for DXTn compressed textures.
EVDF_TEXTURE_COMPRESSED_DXT,
//! Support for PVRTC compressed textures.
EVDF_TEXTURE_COMPRESSED_PVRTC,
//! Support for PVRTC2 compressed textures.
EVDF_TEXTURE_COMPRESSED_PVRTC2,
//! Support for ETC1 compressed textures.
EVDF_TEXTURE_COMPRESSED_ETC1,
//! Support for ETC2 compressed textures.
EVDF_TEXTURE_COMPRESSED_ETC2,
//! Support for cube map textures.
EVDF_TEXTURE_CUBEMAP,
@ -135,3 +151,7 @@ enum E_VIDEO_DRIVER_FEATURE
} // end namespace video
} // end namespace irr
#endif

63
include/EDriverTypes.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_DRIVER_TYPES_H_INCLUDED__
#define __E_DRIVER_TYPES_H_INCLUDED__
#include "irrTypes.h"
@ -19,6 +20,33 @@ enum E_DRIVER_TYPE
render and display any graphics. */
EDT_NULL,
//! The Irrlicht Engine Software renderer.
/** Runs on all platforms, with every hardware. It should only
be used for 2d graphics, but it can also perform some primitive
3d functions. These 3d drawing functions are quite fast, but
very inaccurate, and don't even support clipping in 3D mode. */
EDT_SOFTWARE,
//! The Burning's Software Renderer, an alternative software renderer
/** Basically it can be described as the Irrlicht Software
renderer on steroids. It rasterizes 3D geometry perfectly: It
is able to perform correct 3d clipping, perspective correct
texture mapping, perspective correct color mapping, and renders
sub pixel correct, sub texel correct primitives. In addition,
it does bilinear texel filtering and supports more materials
than the EDT_SOFTWARE driver. This renderer has been written
entirely by Thomas Alten, thanks a lot for this huge
contribution. */
EDT_BURNINGSVIDEO,
//! Direct3D8 device is longer supported in Irrlicht. You have to go back to Irrlicht 1.8 if you still need that.
DEPRECATED_EDT_DIRECT3D8_NO_LONGER_EXISTS, // keep enum to avoid breaking enumeration order (might be used in ini-files, serialization, etc)
//! Direct3D 9 device, only available on Win32 platforms.
/** Performs hardware accelerated rendering of 3D and 2D
primitives. */
EDT_DIRECT3D9,
//! OpenGL device, available on most platforms.
/** Performs hardware accelerated rendering of 3D and 2D
primitives. */
@ -34,11 +62,40 @@ enum E_DRIVER_TYPE
//! WebGL1 friendly subset of OpenGL-ES 2.x driver for Emscripten
EDT_WEBGL1,
EDT_OPENGL3,
//! No driver, just for counting the elements
EDT_COUNT
};
const c8* const DRIVER_TYPE_NAMES[] =
{
"NullDriver",
"Software Renderer",
"Burning's Video",
"Direct3D 8.1",
"Direct3D 9.0c",
"OpenGL 1.x/2.x/3.x",
"OpenGL ES1",
"OpenGL ES2",
"WebGL 1",
0
};
const c8* const DRIVER_TYPE_NAMES_SHORT[] =
{
"null",
"software",
"burning",
"d3d8",
"d3d9",
"opengl",
"ogles1",
"ogles2",
"webgl1",
0
};
} // end namespace video
} // end namespace irr
#endif

6
include/EFocusFlags.h
View file

@ -1,7 +1,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef E_FOCUS_FLAGS_H_INCLUDED__
#define E_FOCUS_FLAGS_H_INCLUDED__
namespace irr
{
@ -32,3 +33,6 @@ enum EFOCUS_FLAG
} // namespace gui
} // namespace irr
#endif

10
include/EGUIAlignment.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_GUI_ALIGNMENT_H_INCLUDED__
#define __E_GUI_ALIGNMENT_H_INCLUDED__
#include "irrTypes.h"
@ -23,13 +24,16 @@ enum EGUI_ALIGNMENT
};
//! Names for alignments
const c8 *const GUIAlignmentNames[] = {
const c8* const GUIAlignmentNames[] =
{
"upperLeft",
"lowerRight",
"center",
"scale",
0,
0
};
} // namespace gui
} // namespace irr
#endif // __E_GUI_ALIGNMENT_H_INCLUDED__

17
include/EGUIElementTypes.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_GUI_ELEMENT_TYPES_H_INCLUDED__
#define __E_GUI_ELEMENT_TYPES_H_INCLUDED__
#include "irrTypes.h"
@ -90,6 +91,9 @@ enum EGUI_ELEMENT_TYPE
//! The root of the GUI
EGUIET_ROOT,
//! IGUIProfiler
EGUIET_PROFILER,
//! Not an element, amount of elements in there
EGUIET_COUNT,
@ -99,7 +103,8 @@ enum EGUI_ELEMENT_TYPE
};
//! Names for built-in element types
const c8 *const GUIElementTypeNames[] = {
const c8* const GUIElementTypeNames[] =
{
"button",
"checkBox",
"comboBox",
@ -126,8 +131,14 @@ const c8 *const GUIElementTypeNames[] = {
"element",
"root",
"profiler",
0,
0
};
} // end namespace gui
} // end namespace irr
#endif

6
include/EHardwareBufferFlags.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_HARDWARE_BUFFER_FLAGS_INCLUDED__
#define __E_HARDWARE_BUFFER_FLAGS_INCLUDED__
namespace irr
{
@ -38,3 +39,6 @@ enum E_BUFFER_TYPE
} // end namespace scene
} // end namespace irr
#endif

101
include/EMaterialFlags.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
#ifndef __E_MATERIAL_FLAGS_H_INCLUDED__
#define __E_MATERIAL_FLAGS_H_INCLUDED__
namespace irr
{
namespace video
{
//! Material flags
enum E_MATERIAL_FLAG
{
//! Draw as wireframe or filled triangles? Default: false
EMF_WIREFRAME = 0x1,
//! Draw as point cloud or filled triangles? Default: false
EMF_POINTCLOUD = 0x2,
//! Flat or Gouraud shading? Default: true
EMF_GOURAUD_SHADING = 0x4,
//! Will this material be lighted? Default: true
EMF_LIGHTING = 0x8,
//! Is the ZBuffer enabled? Default: true
EMF_ZBUFFER = 0x10,
//! May be written to the zbuffer or is it readonly. Default: true
/** This flag is ignored, if the material type is a transparent type. */
EMF_ZWRITE_ENABLE = 0x20,
//! Is backface culling enabled? Default: true
EMF_BACK_FACE_CULLING = 0x40,
//! Is frontface culling enabled? Default: false
/** Overrides EMF_BACK_FACE_CULLING if both are enabled. */
EMF_FRONT_FACE_CULLING = 0x80,
//! Is bilinear filtering enabled? Default: true
EMF_BILINEAR_FILTER = 0x100,
//! Is trilinear filtering enabled? Default: false
/** If the trilinear filter flag is enabled,
the bilinear filtering flag is ignored. */
EMF_TRILINEAR_FILTER = 0x200,
//! Is anisotropic filtering? Default: false
/** In Irrlicht you can use anisotropic texture filtering in
conjunction with bilinear or trilinear texture filtering
to improve rendering results. Primitives will look less
blurry with this flag switched on. */
EMF_ANISOTROPIC_FILTER = 0x400,
//! Is fog enabled? Default: false
EMF_FOG_ENABLE = 0x800,
//! Normalizes normals. Default: false
/** You can enable this if you need to scale a dynamic lighted
model. Usually, its normals will get scaled too then and it
will get darker. If you enable the EMF_NORMALIZE_NORMALS flag,
the normals will be normalized again, and the model will look
as bright as it should. */
EMF_NORMALIZE_NORMALS = 0x1000,
//! Access to all layers texture wrap settings. Overwrites separate layer settings.
/** Note that if you want to change TextureWrapU, TextureWrapV, TextureWrapW
independently, then you can't work with this flag, but will have to set the variables
directly. */
EMF_TEXTURE_WRAP = 0x2000,
//! AntiAliasing mode
EMF_ANTI_ALIASING = 0x4000,
//! ColorMask bits, for enabling the color planes
EMF_COLOR_MASK = 0x8000,
//! ColorMaterial enum for vertex color interpretation
EMF_COLOR_MATERIAL = 0x10000,
//! Flag for enabling/disabling mipmap usage
EMF_USE_MIP_MAPS = 0x20000,
//! Flag for blend operation
EMF_BLEND_OPERATION = 0x40000,
//! Flag for polygon offset
EMF_POLYGON_OFFSET = 0x80000,
//! Flag for blend factor
EMF_BLEND_FACTOR = 0x160000
};
} // end namespace video
} // end namespace irr
#endif // __E_MATERIAL_FLAGS_H_INCLUDED__

82
include/EMaterialProps.h
View file

@ -1,82 +0,0 @@
// 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

105
include/EMaterialTypes.h
View file

@ -2,9 +2,8 @@
// 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"
#ifndef __E_MATERIAL_TYPES_H_INCLUDED__
#define __E_MATERIAL_TYPES_H_INCLUDED__
namespace irr
{
@ -19,6 +18,75 @@ enum E_MATERIAL_TYPE
diffuse material. */
EMT_SOLID = 0,
//! Solid material with 2 texture layers.
/** The second is blended onto the first using the alpha value
of the vertex colors. This material is currently not implemented in OpenGL.
*/
EMT_SOLID_2_LAYER,
//! Material type with standard lightmap technique
/** There should be 2 textures: The first texture layer is a
diffuse map, the second is a light map. Dynamic light is
ignored. */
EMT_LIGHTMAP,
//! Material type with lightmap technique like EMT_LIGHTMAP.
/** But lightmap and diffuse texture are added instead of modulated. */
EMT_LIGHTMAP_ADD,
//! Material type with standard lightmap technique
/** There should be 2 textures: The first texture layer is a
diffuse map, the second is a light map. Dynamic light is
ignored. The texture colors are effectively multiplied by 2
for brightening. Like known in DirectX as D3DTOP_MODULATE2X. */
EMT_LIGHTMAP_M2,
//! Material type with standard lightmap technique
/** There should be 2 textures: The first texture layer is a
diffuse map, the second is a light map. Dynamic light is
ignored. The texture colors are effectively multiplied by 4
for brightening. Like known in DirectX as D3DTOP_MODULATE4X. */
EMT_LIGHTMAP_M4,
//! Like EMT_LIGHTMAP, but also supports dynamic lighting.
EMT_LIGHTMAP_LIGHTING,
//! Like EMT_LIGHTMAP_M2, but also supports dynamic lighting.
EMT_LIGHTMAP_LIGHTING_M2,
//! Like EMT_LIGHTMAP_M4, but also supports dynamic lighting.
EMT_LIGHTMAP_LIGHTING_M4,
//! Detail mapped material.
/** The first texture is diffuse color map, the second is added
to this and usually displayed with a bigger scale value so that
it adds more detail. The detail map is added to the diffuse map
using ADD_SIGNED, so that it is possible to add and subtract
color from the diffuse map. For example a value of
(127,127,127) will not change the appearance of the diffuse map
at all. Often used for terrain rendering. */
EMT_DETAIL_MAP,
//! Look like a reflection of the environment around it.
/** To make this possible, a texture called 'sphere map' is
used, which must be set as the first texture. */
EMT_SPHERE_MAP,
//! A reflecting material with an optional non reflecting texture layer.
/** The reflection map should be set as first texture. */
EMT_REFLECTION_2_LAYER,
//! A transparent material.
/** Only the first texture is used. The new color is calculated
by simply adding the source color and the dest color. This
means if for example a billboard using a texture with black
background and a red circle on it is drawn with this material,
the result is that only the red circle will be drawn a little
bit transparent, and everything which was black is 100%
transparent and not visible. This material type is useful for
particle effects. */
EMT_TRANSPARENT_ADD_COLOR,
//! 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
@ -47,6 +115,12 @@ enum E_MATERIAL_TYPE
//! Makes the material transparent based on the vertex alpha value.
EMT_TRANSPARENT_VERTEX_ALPHA,
//! A transparent reflecting material with an optional additional non reflecting texture layer.
/** The reflection map should be set as first texture. The
transparency depends on the alpha value in the vertex colors. A
texture which will not reflect can be set as second texture.*/
EMT_TRANSPARENT_REFLECTION_2_LAYER,
//! BlendFunc = source * sourceFactor + dest * destFactor ( E_BLEND_FUNC )
/** Using only first texture. Generic blending method.
The blend function is set to SMaterial::MaterialTypeParam with
@ -58,17 +132,32 @@ enum E_MATERIAL_TYPE
};
//! Array holding the built in material type names
const char *const sBuiltInMaterialTypeNames[] = {
const char* const sBuiltInMaterialTypeNames[] =
{
"solid",
"solid_2layer",
"lightmap",
"lightmap_add",
"lightmap_m2",
"lightmap_m4",
"lightmap_light",
"lightmap_light_m2",
"lightmap_light_m4",
"detail_map",
"sphere_map",
"reflection_2layer",
"trans_add",
"trans_alphach",
"trans_alphach_ref",
"trans_vertex_alpha",
"trans_reflection_2layer",
"onetexture_blend",
0,
0
};
constexpr u32 numBuiltInMaterials =
sizeof(sBuiltInMaterialTypeNames) / sizeof(char *) - 1;
} // end namespace video
} // end namespace irr
#endif // __E_MATERIAL_TYPES_H_INCLUDED__

65
include/EMeshWriterEnums.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
#ifndef __E_MESH_WRITER_ENUMS_H_INCLUDED__
#define __E_MESH_WRITER_ENUMS_H_INCLUDED__
#include "irrTypes.h"
namespace irr
{
namespace scene
{
//! An enumeration for all supported types of built-in mesh writers
/** A scene mesh writers is represented by a four character code
such as 'irrm' or 'coll' instead of simple numbers, to avoid
name clashes with external mesh writers.*/
enum EMESH_WRITER_TYPE
{
//! Irrlicht native mesh writer, for static .irrmesh files.
EMWT_IRR_MESH = MAKE_IRR_ID('i','r','r','m'),
//! COLLADA mesh writer for .dae and .xml files
EMWT_COLLADA = MAKE_IRR_ID('c','o','l','l'),
//! STL mesh writer for .stl files
EMWT_STL = MAKE_IRR_ID('s','t','l',0),
//! OBJ mesh writer for .obj files
EMWT_OBJ = MAKE_IRR_ID('o','b','j',0),
//! PLY mesh writer for .ply files
EMWT_PLY = MAKE_IRR_ID('p','l','y',0),
//! B3D mesh writer, for static .b3d files
EMWT_B3D = MAKE_IRR_ID('b', '3', 'd', 0)
};
//! flags configuring mesh writing
enum E_MESH_WRITER_FLAGS
{
//! no writer flags
EMWF_NONE = 0,
//! write lightmap textures out if possible
//! Currently not used by any Irrlicht mesh-writer
// (Note: User meshwriters can still use it)
EMWF_WRITE_LIGHTMAPS = 0x1,
//! write in a way that consumes less disk space
// (Note: Mainly there for user meshwriters)
EMWF_WRITE_COMPRESSED = 0x2,
//! write in binary format rather than text
EMWF_WRITE_BINARY = 0x4
};
} // end namespace scene
} // end namespace irr
#endif // __E_MESH_WRITER_ENUMS_H_INCLUDED__

20
include/EPrimitiveTypes.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_PRIMITIVE_TYPES_H_INCLUDED__
#define __E_PRIMITIVE_TYPES_H_INCLUDED__
namespace irr
{
@ -35,9 +36,26 @@ enum E_PRIMITIVE_TYPE
//! Explicitly set all vertices for each triangle.
EPT_TRIANGLES,
//! After the first two vertices each further two vertices create a quad with the preceding two.
//! Not supported by Direct3D
EPT_QUAD_STRIP,
//! Every four vertices create a quad.
//! Not supported by Direct3D
//! Deprecated with newer OpenGL drivers
EPT_QUADS,
//! Just as LINE_LOOP, but filled.
//! Not supported by Direct3D
//! Deprecated with newer OpenGL drivers
EPT_POLYGON,
//! The single vertices are expanded to quad billboards on the GPU.
EPT_POINT_SPRITES
};
} // end namespace scene
} // end namespace irr
#endif

6
include/EReadFileType.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_READ_FILE_TYPES_H_INCLUDED__
#define __E_READ_FILE_TYPES_H_INCLUDED__
#include "irrTypes.h"
@ -28,3 +29,6 @@ enum EREAD_FILE_TYPE
};
} // end namespace io
} // end namespace irr
#endif

9
include/ESceneNodeTypes.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __E_SCENE_NODE_TYPES_H_INCLUDED__
#define __E_SCENE_NODE_TYPES_H_INCLUDED__
#include "irrTypes.h"
@ -45,5 +46,11 @@ enum ESCENE_NODE_TYPE
ESNT_ANY = MAKE_IRR_ID('a','n','y','_')
};
} // end namespace scene
} // end namespace irr
#endif

7
include/EShaderTypes.h
View file

@ -1,4 +1,5 @@
#pragma once
#ifndef __E_SHADER_TYPES_H_INCLUDED__
#define __E_SHADER_TYPES_H_INCLUDED__
#include "irrTypes.h"
@ -81,5 +82,9 @@ const c8 *const GEOMETRY_SHADER_TYPE_NAMES[] = {
"gs_4_0",
0 };
} // end namespace video
} // end namespace irr
#endif // __E_SHADER_TYPES_H_INCLUDED__

10
include/EVertexAttributes.h
View file

@ -1,4 +1,5 @@
#pragma once
#ifndef __E_VERTEX_ATTRIBUTES_H_INCLUDED__
#define __E_VERTEX_ATTRIBUTES_H_INCLUDED__
namespace irr
{
@ -19,7 +20,8 @@ enum E_VERTEX_ATTRIBUTES
};
//! Array holding the built in vertex attribute names
const char *const sBuiltInVertexAttributeNames[] = {
const char* const sBuiltInVertexAttributeNames[] =
{
"inVertexPosition",
"inVertexNormal",
"inVertexColor",
@ -27,8 +29,10 @@ const char *const sBuiltInVertexAttributeNames[] = {
"inTexCoord1",
"inVertexTangent",
"inVertexBinormal",
0,
0
};
} // end namespace video
} // end namespace irr
#endif //__E_VERTEX_ATTRIBUTES_H_INCLUDED__

9
include/IAnimatedMesh.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_ANIMATED_MESH_H_INCLUDED__
#define __I_ANIMATED_MESH_H_INCLUDED__
#include "aabbox3d.h"
#include "IMesh.h"
@ -19,6 +20,7 @@ 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,
@ -59,7 +61,7 @@ public:
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
virtual E_ANIMATED_MESH_TYPE getMeshType() const _IRR_OVERRIDE_
{
return EAMT_UNKNOWN;
}
@ -67,3 +69,6 @@ public:
} // end namespace scene
} // end namespace irr
#endif

14
include/IAnimatedMeshSceneNode.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_ANIMATED_MESH_SCENE_NODE_H_INCLUDED__
#define __I_ANIMATED_MESH_SCENE_NODE_H_INCLUDED__
#include "ISceneNode.h"
#include "IBoneSceneNode.h"
@ -24,6 +25,7 @@ enum E_JOINT_UPDATE_ON_RENDER
EJUOR_CONTROL
};
class IAnimatedMeshSceneNode;
//! Callback interface for catching events of ended animations.
@ -34,6 +36,7 @@ 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.
@ -45,12 +48,13 @@ public:
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) {}
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f))
: ISceneNode(parent, mgr, id, position, rotation, scale) {}
//! Destructor
virtual ~IAnimatedMeshSceneNode() {}
@ -163,7 +167,11 @@ public:
\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
#endif

40
include/IAttributes.h
View file

@ -2,13 +2,29 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_ATTRIBUTES_H_INCLUDED__
#define __I_ATTRIBUTES_H_INCLUDED__
#include "IReferenceCounted.h"
#include "EAttributes.h"
// not needed here but I can't be bothered to clean the transitive includes up.
#include "SColor.h"
#include "vector3d.h"
#include "vector2d.h"
#include "line2d.h"
#include "line3d.h"
#include "triangle3d.h"
#include "position2d.h"
#include "rect.h"
#include "dimension2d.h"
#include "matrix4.h"
#include "quaternion.h"
#include "plane3d.h"
#include "triangle3d.h"
#include "line2d.h"
#include "line3d.h"
#include "irrString.h"
#include "irrArray.h"
#include "EAttributes.h"
#include "path.h"
namespace irr
{
@ -23,6 +39,7 @@ namespace io
class IAttributes : public virtual IReferenceCounted
{
public:
//! Returns amount of attributes in this collection of attributes.
virtual u32 getAttributeCount() const = 0;
@ -38,6 +55,16 @@ public:
//! \param index: Index value, must be between 0 and getAttributeCount()-1.
virtual E_ATTRIBUTE_TYPE getAttributeType(s32 index) const = 0;
//! Returns the type string of the attribute
//! \param attributeName: String for the attribute type
//! \param defaultNotFound Value returned when attributeName was not found
virtual const wchar_t* getAttributeTypeString(const c8* attributeName, const wchar_t* defaultNotFound = L"unknown") const = 0;
//! Returns the type string of the attribute by index.
//! \param index: Index value, must be between 0 and getAttributeCount()-1.
//! \param defaultNotFound Value returned for an invalid index
virtual const wchar_t* getAttributeTypeString(s32 index, const wchar_t* defaultNotFound = L"unknown") const = 0;
//! Returns if an attribute with a name exists
virtual bool existsAttribute(const c8* attributeName) const = 0;
@ -47,6 +74,7 @@ public:
//! Removes all attributes
virtual void clear() = 0;
/*
Integer Attribute
@ -97,6 +125,7 @@ public:
//! Sets an attribute as float value
virtual void setAttribute(s32 index, f32 value) = 0;
/*
Bool Attribute
*/
@ -119,7 +148,10 @@ public:
//! Sets an attribute as boolean value
virtual void setAttribute(s32 index, bool value) = 0;
};
} // end namespace io
} // end namespace irr
#endif

12
include/IBillboardSceneNode.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_BILLBOARD_SCENE_NODE_H_INCLUDED__
#define __I_BILLBOARD_SCENE_NODE_H_INCLUDED__
#include "ISceneNode.h"
@ -21,10 +22,11 @@ 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) {}
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;
@ -88,3 +90,7 @@ public:
} // end namespace scene
} // end namespace irr
#endif

22
include/IBoneSceneNode.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_BONE_SCENE_NODE_H_INCLUDED__
#define __I_BONE_SCENE_NODE_H_INCLUDED__
#include "ISceneNode.h"
@ -40,21 +41,28 @@ enum E_BONE_SKINNING_SPACE
};
//! Names for bone animation modes
const c8 *const BoneAnimationModeNames[] = {
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 name of the bone
/** \deprecated Use getName instead. This method may be removed by Irrlicht 1.9 */
_IRR_DEPRECATED_ virtual const c8* getBoneName() const { return getName(); }
//! Get the index of the bone
virtual u32 getBoneIndex() const = 0;
@ -66,17 +74,17 @@ public:
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;
virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_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;
virtual void OnAnimate(u32 timeMs) _IRR_OVERRIDE_ =0;
//! The render method.
/** Does nothing as bones are not visible. */
void render() override {}
virtual void render() _IRR_OVERRIDE_ { }
//! How the relative transformation of the bone is used
virtual void setSkinningSpace( E_BONE_SKINNING_SPACE space ) =0;
@ -92,5 +100,9 @@ public:
s32 rotationHint;
};
} // end namespace scene
} // end namespace irr
#endif

17
include/ICameraSceneNode.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_CAMERA_SCENE_NODE_H_INCLUDED__
#define __I_CAMERA_SCENE_NODE_H_INCLUDED__
#include "ISceneNode.h"
#include "IEventReceiver.h"
@ -22,13 +23,13 @@ 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) {}
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
@ -71,7 +72,7 @@ public:
ISceneManager::addCameraSceneNodeFPS, may want to get
this input for changing their position, look at target or
whatever. */
bool OnEvent(const SEvent &event) override = 0;
virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_ =0;
//! Sets the look at target of the camera
/** If the camera's target and rotation are bound ( @see
@ -89,7 +90,7 @@ public:
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;
virtual void setRotation(const core::vector3df& rotation) _IRR_OVERRIDE_ =0;
//! Gets the current look at target of the camera
/** \return The current look at target of the camera, in world co-ordinates */
@ -172,6 +173,7 @@ public:
virtual bool getTargetAndRotationBinding(void) const =0;
protected:
void cloneMembers(const ICameraSceneNode* toCopyFrom)
{
IsOrthogonal = toCopyFrom->IsOrthogonal;
@ -182,3 +184,6 @@ protected:
} // end namespace scene
} // end namespace irr
#endif

6
include/IContextManager.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __IRR_I_CONTEXT_MANAGER_H_INCLUDED__
#define __IRR_I_CONTEXT_MANAGER_H_INCLUDED__
#include "SExposedVideoData.h"
#include "SIrrCreationParameters.h"
@ -57,3 +58,6 @@ public:
} // end namespace video
} // end namespace irr
#endif

26
include/ICursorControl.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_CURSOR_CONTROL_H_INCLUDED__
#define __I_CURSOR_CONTROL_H_INCLUDED__
#include "IReferenceCounted.h"
#include "position2d.h"
@ -25,7 +26,7 @@ enum ECURSOR_ICON
ECI_HELP, // Arrow and question mark
ECI_IBEAM, // typical text-selection cursor
ECI_NO, // should not click icon
ECI_WAIT, // hourglass
ECI_WAIT, // hourclass
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
@ -41,7 +42,8 @@ enum ECURSOR_ICON
};
//! Names for ECURSOR_ICON
const c8 *const GUICursorIconNames[ECI_COUNT + 1] = {
const c8* const GUICursorIconNames[ECI_COUNT+1] =
{
"normal",
"cross",
"hand",
@ -55,19 +57,19 @@ const c8 *const GUICursorIconNames[ECI_COUNT + 1] = {
"sizens",
"sizewe",
"sizeup",
0,
0
};
//! structure used to set sprites as cursors.
struct SCursorSprite
{
SCursorSprite() :
SpriteBank(0), SpriteId(-1)
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)
SCursorSprite( gui::IGUISpriteBank * spriteBank, s32 spriteId, const core::position2d<s32> &hotspot=(core::position2d<s32>(0,0)) )
: SpriteBank(spriteBank), SpriteId(spriteId), HotSpot(hotspot)
{
}
@ -95,6 +97,7 @@ enum ECURSOR_PLATFORM_BEHAVIOR
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. */
@ -157,9 +160,6 @@ public:
\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 */
@ -191,5 +191,9 @@ public:
virtual ECURSOR_PLATFORM_BEHAVIOR getPlatformBehavior() const { return ECPB_NONE; }
};
} // end namespace gui
} // end namespace irr
#endif

12
include/IDummyTransformationSceneNode.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_DUMMY_TRANSFORMATION_SCENE_NODE_H_INCLUDED__
#define __I_DUMMY_TRANSFORMATION_SCENE_NODE_H_INCLUDED__
#include "ISceneNode.h"
@ -22,9 +23,10 @@ joint scene nodes when playing skeletal animations.
class IDummyTransformationSceneNode : public ISceneNode
{
public:
//! Constructor
IDummyTransformationSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id) :
ISceneNode(parent, mgr, id) {}
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
@ -34,3 +36,7 @@ public:
} // end namespace scene
} // end namespace irr
#endif

24
include/IEventReceiver.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_EVENT_RECEIVER_H_INCLUDED__
#define __I_EVENT_RECEIVER_H_INCLUDED__
#include "ILogger.h"
#include "Keycodes.h"
@ -262,10 +263,6 @@ enum EGUI_EVENT_TYPE
//! 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,
@ -308,6 +305,7 @@ enum EGUI_EVENT_TYPE
};
} // end namespace gui
//! SEvents hold information about an event. See irr::IEventReceiver for details on event handling.
struct SEvent
{
@ -322,6 +320,7 @@ struct SEvent
//! Type of GUI Event
gui::EGUI_EVENT_TYPE EventType;
};
//! Any kind of mouse event.
@ -453,10 +452,10 @@ struct SEvent
/** 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. */
* active device, _IRR_COMPILE_WITH_JOYSTICK_EVENTS_ is defined, 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
@ -570,6 +569,7 @@ struct SEvent
struct SSystemEvent SystemEvent;
struct SApplicationEvent ApplicationEvent;
};
};
//! Interface of an object which can receive events.
@ -581,6 +581,7 @@ path it takes through the system. */
class IEventReceiver
{
public:
//! Destructor
virtual ~IEventReceiver() {}
@ -593,6 +594,7 @@ public:
virtual bool OnEvent(const SEvent& event) = 0;
};
//! Information on a joystick, returned from @ref irr::IrrlichtDevice::activateJoysticks()
struct SJoystickInfo
{
@ -629,4 +631,8 @@ struct SJoystickInfo
} PovHat;
}; // struct SJoystickInfo
} // end namespace irr
#endif

23
include/IFileArchive.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_FILE_ARCHIVE_H_INCLUDED__
#define __I_FILE_ARCHIVE_H_INCLUDED__
#include "IReadFile.h"
#include "IFileList.h"
@ -29,6 +30,21 @@ enum E_FILE_ARCHIVE_TYPE
//! A gzip archive
EFAT_GZIP = MAKE_IRR_ID('g','z','i','p'),
//! A virtual directory
EFAT_FOLDER = MAKE_IRR_ID('f','l','d','r'),
//! An ID Software PAK archive
EFAT_PAK = MAKE_IRR_ID('P','A','K', 0),
//! A Nebula Device archive
EFAT_NPK = MAKE_IRR_ID('N','P','K', 0),
//! A Tape ARchive
EFAT_TAR = MAKE_IRR_ID('T','A','R', 0),
//! A wad Archive, Quake2, Halflife
EFAT_WAD = MAKE_IRR_ID('W','A','D', 0),
//! An Android asset file archive
EFAT_ANDROID_ASSET = MAKE_IRR_ID('A','S','S','E'),
@ -40,6 +56,7 @@ enum E_FILE_ARCHIVE_TYPE
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
@ -123,5 +140,9 @@ public:
virtual IFileArchive* createArchive(io::IReadFile* file, bool ignoreCase, bool ignorePaths) const =0;
};
} // end namespace io
} // end namespace irr
#endif

7
include/IFileList.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_FILE_LIST_H_INCLUDED__
#define __I_FILE_LIST_H_INCLUDED__
#include "IReferenceCounted.h"
#include "path.h"
@ -87,3 +88,7 @@ public:
} // end namespace irr
} // end namespace io
#endif

62
include/IFileSystem.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_FILE_SYSTEM_H_INCLUDED__
#define __I_FILE_SYSTEM_H_INCLUDED__
#include "IReferenceCounted.h"
#include "IFileArchive.h"
@ -21,6 +22,7 @@ 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
@ -28,6 +30,7 @@ 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.
@ -75,6 +78,7 @@ public:
*/
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
@ -206,6 +210,58 @@ public:
\return A pointer to the specified loader, 0 if the index is incorrect. */
virtual IArchiveLoader* getArchiveLoader(u32 index) const = 0;
//! Adds a zip archive to the file system.
/** \deprecated This function is provided for compatibility
with older versions of Irrlicht and may be removed in Irrlicht 1.9,
you should use addFileArchive instead.
After calling this, the Irrlicht Engine will search and open files directly from this archive too.
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 no different than .zip files.
\param filename: Filename of the zip 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.
\return True if the archive was added successfully, false if not. */
_IRR_DEPRECATED_ virtual bool addZipFileArchive(const c8* filename, bool ignoreCase=true, bool ignorePaths=true)
{
return addFileArchive(filename, ignoreCase, ignorePaths, EFAT_ZIP);
}
//! Adds an unzipped archive (or basedirectory with subdirectories..) to the file system.
/** \deprecated This function is provided for compatibility
with older versions of Irrlicht and may be removed in Irrlicht 1.9,
you should use addFileArchive instead.
Useful for handling data which will be in a zip file
\param filename: Filename of the unzipped zip archive base directory 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.
\return True if the archive was added successful, false if not. */
_IRR_DEPRECATED_ virtual bool addFolderFileArchive(const c8* filename, bool ignoreCase=true, bool ignorePaths=true)
{
return addFileArchive(filename, ignoreCase, ignorePaths, EFAT_FOLDER);
}
//! Adds a pak archive to the file system.
/** \deprecated This function is provided for compatibility
with older versions of Irrlicht and may be removed in Irrlicht 1.9,
you should use addFileArchive instead.
After calling this, the Irrlicht Engine will search and open files directly from this archive too.
This is useful for hiding data from the end user, speeding up file access and making it possible to
access for example Quake2/KingPin/Hexen2 .pak files
\param filename: Filename of the pak 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.(should not use with Quake2 paks
\return True if the archive was added successful, false if not. */
_IRR_DEPRECATED_ virtual bool addPakFileArchive(const c8* filename, bool ignoreCase=true, bool ignorePaths=true)
{
return addFileArchive(filename, ignoreCase, ignorePaths, EFAT_PAK);
}
//! Get the current working directory.
/** \return Current working directory as a string. */
virtual const path& getWorkingDirectory() =0;
@ -261,5 +317,9 @@ public:
virtual bool existFile(const path& filename) const =0;
};
} // end namespace io
} // end namespace irr
#endif

108
include/IGPUProgrammingServices.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GPU_PROGRAMMING_SERVICES_H_INCLUDED__
#define __I_GPU_PROGRAMMING_SERVICES_H_INCLUDED__
#include "EShaderTypes.h"
#include "EMaterialTypes.h"
@ -27,6 +28,7 @@ class IShaderConstantSetCallBack;
class IGPUProgrammingServices
{
public:
//! Destructor
virtual ~IGPUProgrammingServices() {}
@ -153,7 +155,7 @@ public:
callback, baseMaterial, userData);
}
//! Like addHighLevelShaderMaterial(), but loads from files.
//! Like IGPUProgrammingServices::addShaderMaterial(), 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.
@ -277,7 +279,7 @@ public:
callback, baseMaterial, userData);
}
//! Like addHighLevelShaderMaterial(), but loads from files.
//! Like IGPUProgrammingServices::addShaderMaterial(), 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.
@ -355,15 +357,99 @@ public:
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;
//! Adds a new ASM shader material renderer to the VideoDriver
/** Note that it is a good idea to call IVideoDriver::queryFeature() in
advance to check if the IVideoDriver supports the vertex and/or pixel
shader version your are using.
The material is added to the VideoDriver like with
IVideoDriver::addMaterialRenderer() and can be used like it had been
added with that method.
\param vertexShaderProgram String containing the source of the vertex
shader program. This can be 0 if no vertex program shall be used.
For DX8 programs, the will always input registers look like this: v0:
position, v1: normal, v2: color, v3: texture coordinates, v4: texture
coordinates 2 if available.
For DX9 programs, you can manually set the registers using the dcl_
statements.
\param pixelShaderProgram String containing the source of the pixel
shader program. This can be 0 if you don't want to use a pixel shader.
\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 Returns the number of the material type which can be set in
SMaterial::MaterialType to use the renderer. -1 is returned if an
error occurred. -1 is returned for example if a vertex or pixel shader
program could not be compiled, the error strings are then printed out
into the error log, and can be caught with a custom event receiver. */
virtual s32 addShaderMaterial(const c8* vertexShaderProgram = 0,
const c8* pixelShaderProgram = 0,
IShaderConstantSetCallBack* callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0) = 0;
//! Like IGPUProgrammingServices::addShaderMaterial(), but loads from files.
/** \param vertexShaderProgram Text file containing the source of the
vertex shader program. Set to 0 if no shader shall be created.
\param pixelShaderProgram Text file containing the source of the pixel
shader program. Set to 0 if no shader shall be created.
\param callback Pointer to an IShaderConstantSetCallback object to
which the OnSetConstants function is called.
\param baseMaterial baseMaterial
\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 Returns the number of the material type which can be set in
SMaterial::MaterialType to use the renderer. -1 is returned if an
error occurred. -1 is returned for example if a vertex or pixel shader
program could not be compiled, the error strings are then printed out
into the error log, and can be caught with a custom event receiver. */
virtual s32 addShaderMaterialFromFiles(io::IReadFile* vertexShaderProgram,
io::IReadFile* pixelShaderProgram,
IShaderConstantSetCallBack* callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0) = 0;
//! Like IGPUProgrammingServices::addShaderMaterial(), but loads from files.
/** \param vertexShaderProgramFileName Text file name containing the
source of the vertex shader program. Set to 0 if no shader shall be
created.
\param pixelShaderProgramFileName Text file name containing the source
of the pixel shader program. Set to 0 if no shader shall be created.
\param callback Pointer to an IShaderConstantSetCallback object on
which the OnSetConstants function is called.
\param baseMaterial baseMaterial
\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 Returns the number of the material type which can be set in
SMaterial::MaterialType to use the renderer. -1 is returned if an
error occurred. -1 is returned for example if a vertex or pixel shader
program could not be compiled, the error strings are then printed out
into the error log, and can be caught with a custom event receiver. */
virtual s32 addShaderMaterialFromFiles(const io::path& vertexShaderProgramFileName,
const io::path& pixelShaderProgramFileName,
IShaderConstantSetCallBack* callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0) = 0;
};
} // end namespace video
} // end namespace irr
#endif

23
include/IGUIButton.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_BUTTON_H_INCLUDED__
#define __I_GUI_BUTTON_H_INCLUDED__
#include "IGUIElement.h"
@ -45,7 +46,8 @@ enum EGUI_BUTTON_STATE
};
//! Names for gui button state icons
const c8 *const GUIButtonStateNames[EGBS_COUNT + 1] = {
const c8* const GUIButtonStateNames[EGBS_COUNT+1] =
{
"buttonUp",
"buttonDown",
"buttonMouseOver",
@ -53,7 +55,7 @@ const c8 *const GUIButtonStateNames[EGBS_COUNT + 1] = {
"buttonFocused",
"buttonNotFocused",
"buttonDisabled",
0, // count
0 // count
};
//! State of buttons used for drawing texture images.
@ -86,7 +88,8 @@ enum EGUI_BUTTON_IMAGE_STATE
};
//! Names for gui button image states
const c8 *const GUIButtonImageStateNames[EGBIS_COUNT + 1] = {
const c8* const GUIButtonImageStateNames[EGBIS_COUNT+1] =
{
"Image", // not "ImageUp" as it otherwise breaks serialization of old files
"ImageUpOver",
"ImageUpFocused",
@ -96,7 +99,7 @@ const c8 *const GUIButtonImageStateNames[EGBIS_COUNT + 1] = {
"ImageDownFocused",
"ImageDownFocusedOver",
"ImageDisabled",
0, // count
0 // count
};
//! GUI Button interface.
@ -106,9 +109,10 @@ const c8 *const GUIButtonImageStateNames[EGBIS_COUNT + 1] = {
class IGUIButton : public IGUIElement
{
public:
//! constructor
IGUIButton(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_BUTTON, environment, parent, id, rectangle) {}
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.
@ -184,6 +188,7 @@ public:
\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. */
@ -255,5 +260,9 @@ public:
virtual bool getClickControlState() const = 0;
};
} // end namespace gui
} // end namespace irr
#endif

12
include/IGUICheckBox.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_CHECKBOX_H_INCLUDED__
#define __I_GUI_CHECKBOX_H_INCLUDED__
#include "IGUIElement.h"
@ -18,9 +19,10 @@ namespace gui
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) {}
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;
@ -41,7 +43,11 @@ public:
//! 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
#endif

20
include/IGUIComboBox.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_COMBO_BOX_H_INCLUDED__
#define __I_GUI_COMBO_BOX_H_INCLUDED__
#include "IGUIElement.h"
@ -18,9 +19,10 @@ namespace gui
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) {}
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;
@ -50,15 +52,11 @@ public:
//! 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.
EGUIA_LOWEERRIGHT 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). */
EGUIA_LOWEERRIGHT 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
@ -68,5 +66,9 @@ public:
virtual u32 getMaxSelectionRows() const = 0;
};
} // end namespace gui
} // end namespace irr
#endif

12
include/IGUIEditBox.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_EDIT_BOX_H_INCLUDED__
#define __I_GUI_EDIT_BOX_H_INCLUDED__
#include "IGUIElement.h"
#include "SColor.h"
@ -22,9 +23,10 @@ class IGUIFont;
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) {}
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.
@ -147,5 +149,9 @@ public:
virtual irr::u32 getCursorBlinkTime() const = 0;
};
} // end namespace gui
} // end namespace irr
#endif

191
include/IGUIElement.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_ELEMENT_H_INCLUDED__
#define __I_GUI_ELEMENT_H_INCLUDED__
#include "IReferenceCounted.h"
#include "rect.h"
@ -25,11 +26,11 @@ namespace gui
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),
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),
@ -41,12 +42,14 @@ public:
#endif
// if we were given a parent to attach to
if (parent) {
if (parent)
{
parent->addChildToEnd(this);
recalculateAbsolutePosition(true);
}
}
//! Destructor
virtual ~IGUIElement()
{
@ -56,6 +59,7 @@ public:
}
}
//! Returns parent of this element.
IGUIElement* getParent() const
{
@ -68,11 +72,13 @@ public:
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) {
if (Parent)
{
const core::rect<s32>& r2 = Parent->getAbsolutePosition();
core::dimension2df d((f32)(r2.getSize().Width), (f32)(r2.getSize().Height));
@ -101,6 +107,7 @@ public:
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.
@ -124,18 +131,21 @@ public:
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)
@ -144,6 +154,7 @@ public:
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
@ -151,6 +162,7 @@ public:
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)
@ -159,6 +171,7 @@ public:
updateAbsolutePosition();
}
//! Sets the minimum size allowed for this element
void setMinSize(core::dimension2du size)
{
@ -170,6 +183,7 @@ public:
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)
{
@ -178,7 +192,8 @@ public:
AlignTop = top;
AlignBottom = bottom;
if (Parent) {
if (Parent)
{
core::rect<s32> r(Parent->getAbsolutePosition());
core::dimension2df d((f32)r.getSize().Width, (f32)r.getSize().Height);
@ -224,11 +239,13 @@ public:
recalculateAbsolutePosition(false);
// update all children
for (auto child : 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
@ -245,12 +262,14 @@ public:
{
IGUIElement* target = 0;
if (isVisible()) {
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) {
while (it != ie)
{
target = (*it)->getElementFromPoint(point);
if (target)
return target;
@ -265,6 +284,7 @@ public:
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
@ -272,10 +292,12 @@ public:
return AbsoluteClippingRect.isPointInside(point);
}
//! Adds a GUI element as new child of this element.
virtual void addChild(IGUIElement* child)
{
if (child && child != this) {
if ( child && child != this )
{
addChildToEnd(child);
child->updateAbsolutePosition();
}
@ -291,8 +313,7 @@ public:
}
//! Removes all children.
virtual void removeAllChildren()
{
virtual void removeAllChildren() {
while (!Children.empty()) {
auto child = Children.back();
child->remove();
@ -306,30 +327,36 @@ public:
Parent->removeChild(this);
}
//! Draws the element and its children.
virtual void draw()
{
if (isVisible()) {
if ( isVisible() )
{
for (auto child : Children)
child->draw();
}
}
//! animate the element and its children.
virtual void OnPostRender(u32 timeMs)
{
if (isVisible()) {
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
{
@ -356,12 +383,14 @@ public:
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() */
@ -370,6 +399,7 @@ public:
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. */
@ -378,43 +408,51 @@ public:
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) {
if (index < 0)
{
TabOrder = 0;
IGUIElement *el = getTabGroup();
while (IsTabGroup && el && el->Parent)
el = el->Parent;
IGUIElement *first=0, *closest=0;
if (el) {
if (el)
{
// find the highest element number
el->getNextElement(-1, true, IsTabGroup, first, closest, true, true);
if (first) {
el->getNextElement(-1, true, IsTabGroup, first, closest, true);
if (first)
{
TabOrder = first->getTabOrder() + 1;
}
}
} else
}
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. */
@ -423,12 +461,14 @@ public:
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()
{
@ -440,6 +480,7 @@ public:
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.
@ -453,54 +494,63 @@ public:
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
virtual bool OnEvent(const SEvent& event) _IRR_OVERRIDE_
{
return Parent ? Parent->OnEvent(event) : false;
}
//! Brings a child to front
/** \return True if successful, false if not. */
virtual bool bringToFront(IGUIElement* child)
@ -514,6 +564,7 @@ public:
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)
@ -533,6 +584,7 @@ public:
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
@ -544,7 +596,8 @@ public:
{
IGUIElement* e = 0;
for (auto child : Children) {
for (auto child : Children)
{
if (child->getID() == id)
return child;
@ -558,21 +611,25 @@ public:
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 {
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
@ -595,46 +652,62 @@ public:
s32 closestOrder, currentOrder;
while (it != Children.end()) {
while(it != Children.end())
{
// ignore invisible elements and their children
if ( ( (*it)->isVisible() || includeInvisible ) &&
(group == true || (*it)->isTabGroup() == false)) {
(group == true || (*it)->isTabGroup() == false) )
{
// ignore disabled, but children are checked (disabled is currently per element ignoring parent states)
if ((*it)->isEnabled() || includeDisabled) {
if ( (*it)->isEnabled() || includeDisabled )
{
// only check tab stops and those with the same group status
if ((*it)->isTabStop() && ((*it)->isTabGroup() == group)) {
if ((*it)->isTabStop() && ((*it)->isTabGroup() == group))
{
currentOrder = (*it)->getTabOrder();
// is this what we're looking for?
if (currentOrder == wanted) {
if (currentOrder == wanted)
{
closest = *it;
return true;
}
// is it closer than the current closest?
if (closest) {
if (closest)
{
closestOrder = closest->getTabOrder();
if ((reverse && currentOrder > closestOrder && currentOrder < startOrder) || (!reverse && currentOrder < closestOrder && currentOrder > startOrder)) {
if ( ( reverse && currentOrder > closestOrder && currentOrder < startOrder)
||(!reverse && currentOrder < closestOrder && currentOrder > startOrder))
{
closest = *it;
}
} else if ((reverse && currentOrder < startOrder) || (!reverse && currentOrder > startOrder)) {
}
else
if ( (reverse && currentOrder < startOrder) || (!reverse && currentOrder > startOrder) )
{
closest = *it;
}
// is it before the current first?
if (first) {
if (first)
{
closestOrder = first->getTabOrder();
if ((reverse && closestOrder < currentOrder) || (!reverse && closestOrder > currentOrder)) {
if ( (reverse && closestOrder < currentOrder) || (!reverse && closestOrder > currentOrder) )
{
first = *it;
}
} else {
}
else
{
first = *it;
}
}
}
// search within children
if ((*it)->getNextElement(startOrder, reverse, group, first, closest, includeInvisible, includeDisabled)) {
if ((*it)->getNextElement(startOrder, reverse, group, first, closest))
{
return true;
}
}
@ -643,6 +716,7 @@ public:
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.
@ -667,6 +741,7 @@ public:
return type == Type;
}
//! Returns the type name of the gui element.
/** This is needed serializing elements. */
virtual const c8* getTypeName() const
@ -681,6 +756,7 @@ public:
return Name.c_str();
}
//! Sets the name of the element.
/** \param name New name of the gui element. */
virtual void setName(const c8* name)
@ -688,6 +764,7 @@ public:
Name = name;
}
//! Sets the name of the element.
/** \param name New name of the gui element. */
virtual void setName(const core::stringc& name)
@ -695,17 +772,20 @@ public:
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) {
if (child)
{
child->grab(); // prevent destruction when removed
child->remove(); // remove from old parent
child->LastParentRect = getAbsolutePosition();
@ -716,8 +796,7 @@ protected:
#ifndef NDEBUG
template<typename Iterator>
static size_t _fastSetChecksum(Iterator begin, Iterator end)
{
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) {
@ -735,7 +814,8 @@ protected:
const std::vector<IGUIElement*> &neworder)
{
assert(_fastSetChecksum(from, to) == _fastSetChecksum(neworder.begin(), neworder.end()));
for (auto e : neworder) {
for (auto e : neworder)
{
*from = e;
e->ParentPos = from;
++from;
@ -743,6 +823,7 @@ protected:
assert(from == to);
}
// not virtual because needed in constructor
void recalculateAbsolutePosition(bool recursive)
{
@ -750,15 +831,18 @@ protected:
core::rect<s32> parentAbsoluteClip;
f32 fw=0.f, fh=0.f;
if (Parent) {
if (Parent)
{
parentAbsolute = Parent->AbsoluteRect;
if (NoClip) {
if (NoClip)
{
IGUIElement* p=this;
while (p->Parent)
p = p->Parent;
parentAbsoluteClip = p->AbsoluteClippingRect;
} else
}
else
parentAbsoluteClip = Parent->AbsoluteClippingRect;
}
@ -771,7 +855,8 @@ protected:
if (AlignTop == EGUIA_SCALE || AlignBottom == EGUIA_SCALE)
fh = (f32)parentAbsolute.getHeight();
switch (AlignLeft) {
switch (AlignLeft)
{
case EGUIA_UPPERLEFT:
break;
case EGUIA_LOWERRIGHT:
@ -785,7 +870,8 @@ protected:
break;
}
switch (AlignRight) {
switch (AlignRight)
{
case EGUIA_UPPERLEFT:
break;
case EGUIA_LOWERRIGHT:
@ -799,7 +885,8 @@ protected:
break;
}
switch (AlignTop) {
switch (AlignTop)
{
case EGUIA_UPPERLEFT:
break;
case EGUIA_LOWERRIGHT:
@ -813,7 +900,8 @@ protected:
break;
}
switch (AlignBottom) {
switch (AlignBottom)
{
case EGUIA_UPPERLEFT:
break;
case EGUIA_LOWERRIGHT:
@ -854,15 +942,18 @@ protected:
LastParentRect = parentAbsolute;
if (recursive) {
if ( recursive )
{
// update all children
for (auto child : Children) {
for (auto child : Children)
{
child->recalculateAbsolutePosition(recursive);
}
}
}
protected:
//! List of all children of this element
std::list<IGUIElement*> Children;
@ -937,5 +1028,9 @@ protected:
EGUI_ELEMENT_TYPE Type;
};
} // end namespace gui
} // end namespace irr
#endif

9
include/IGUIEnvironment.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_ENVIRONMENT_H_INCLUDED__
#define __I_GUI_ENVIRONMENT_H_INCLUDED__
#include "IReferenceCounted.h"
#include "IGUISkin.h"
@ -58,6 +59,7 @@ class IGUIWindow;
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. */
@ -151,6 +153,7 @@ public:
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
@ -410,5 +413,9 @@ public:
virtual void addToDeletionQueue(IGUIElement* element) = 0;
};
} // end namespace gui
} // end namespace irr
#endif

12
include/IGUIFileOpenDialog.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_FILE_OPEN_DIALOG_H_INCLUDED__
#define __I_GUI_FILE_OPEN_DIALOG_H_INCLUDED__
#include "IGUIElement.h"
#include "path.h"
@ -23,9 +24,10 @@ namespace gui
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) {}
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;
@ -40,5 +42,9 @@ public:
virtual const wchar_t* getDirectoryNameW() const = 0;
};
} // end namespace gui
} // end namespace irr
#endif

7
include/IGUIFont.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_FONT_H_INCLUDED__
#define __I_GUI_FONT_H_INCLUDED__
#include "IReferenceCounted.h"
#include "SColor.h"
@ -38,6 +39,7 @@ enum EGUI_FONT_TYPE
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.
@ -97,3 +99,6 @@ public:
} // end namespace gui
} // end namespace irr
#endif

11
include/IGUIFontBitmap.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_FONT_BITMAP_H_INCLUDED__
#define __I_GUI_FONT_BITMAP_H_INCLUDED__
#include "IGUIFont.h"
@ -16,8 +17,9 @@ class IGUISpriteBank;
class IGUIFontBitmap : public IGUIFont
{
public:
//! Returns the type of this font
EGUI_FONT_TYPE getType() const override { return EGFT_BITMAP; }
virtual EGUI_FONT_TYPE getType() const _IRR_OVERRIDE_ { return EGFT_BITMAP; }
//! returns the parsed Symbol Information
virtual IGUISpriteBank* getSpriteBank() const = 0;
@ -34,8 +36,11 @@ public:
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;
virtual s32 getKerningWidth(const wchar_t* thisLetter=0, const wchar_t* previousLetter=0) const _IRR_OVERRIDE_ = 0;
};
} // end namespace gui
} // end namespace irr
#endif

11
include/IGUIImage.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_IMAGE_H_INCLUDED__
#define __I_GUI_IMAGE_H_INCLUDED__
#include "IGUIElement.h"
@ -18,9 +19,10 @@ namespace gui
class IGUIImage : public IGUIElement
{
public:
//! constructor
IGUIImage(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_IMAGE, environment, parent, id, rectangle) {}
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;
@ -78,5 +80,8 @@ public:
virtual bool isDrawBackgroundEnabled() const = 0;
};
} // end namespace gui
} // end namespace irr
#endif

7
include/IGUIImageList.h
View file

@ -1,7 +1,8 @@
// This file is part of the "Irrlicht Engine".
// written by Reinhard Ostermeier, reinhard@nospam.r-ostermeier.de
#pragma once
#ifndef __I_GUI_IMAGE_LIST_H_INCLUDED__
#define __I_GUI_IMAGE_LIST_H_INCLUDED__
#include "IGUIElement.h"
#include "rect.h"
@ -16,6 +17,7 @@ namespace gui
class IGUIImageList : public virtual IReferenceCounted
{
public:
//! Destructor
virtual ~IGUIImageList() {};
@ -38,3 +40,6 @@ public:
} // end namespace gui
} // end namespace irr
#endif

12
include/IGUIListBox.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_LIST_BOX_H_INCLUDED__
#define __I_GUI_LIST_BOX_H_INCLUDED__
#include "IGUIElement.h"
#include "SColor.h"
@ -29,6 +30,7 @@ enum EGUI_LISTBOX_COLOR
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
@ -38,8 +40,8 @@ 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) {}
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;
@ -132,5 +134,9 @@ public:
virtual IGUIScrollBar* getVerticalScrollBar() const = 0;
};
} // end namespace gui
} // end namespace irr
#endif

12
include/IGUIScrollBar.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_SCROLL_BAR_H_INCLUDED__
#define __I_GUI_SCROLL_BAR_H_INCLUDED__
#include "IGUIElement.h"
@ -18,9 +19,10 @@ namespace gui
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) {}
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;
@ -55,5 +57,9 @@ public:
virtual void setPos(s32 pos) = 0;
};
} // end namespace gui
} // end namespace irr
#endif

37
include/IGUISkin.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_SKIN_H_INCLUDED__
#define __I_GUI_SKIN_H_INCLUDED__
#include "IReferenceCounted.h"
#include "EGUIAlignment.h"
@ -45,7 +46,8 @@ enum EGUI_SKIN_TYPE
};
//! Names for gui element types
const c8 *const GUISkinTypeNames[EGST_COUNT + 1] = {
const c8* const GUISkinTypeNames[EGST_COUNT+1] =
{
"windowsClassic",
"windowsMetallic",
"burning",
@ -53,6 +55,7 @@ const c8 *const GUISkinTypeNames[EGST_COUNT + 1] = {
0,
};
//! Enumeration for skin colors
enum EGUI_DEFAULT_COLOR
{
@ -113,7 +116,8 @@ enum EGUI_DEFAULT_COLOR
};
//! Names for default skin colors
const c8 *const GUISkinColorNames[EGDC_COUNT + 1] = {
const c8* const GUISkinColorNames[EGDC_COUNT+1] =
{
"3DDarkShadow",
"3DShadow",
"3DFace",
@ -197,8 +201,10 @@ enum EGUI_DEFAULT_SIZE
EGDS_COUNT
};
//! Names for default skin sizes
const c8 *const GUISkinSizeNames[EGDS_COUNT + 1] = {
const c8* const GUISkinSizeNames[EGDS_COUNT+1] =
{
"ScrollBarSize",
"MenuHeight",
"WindowButtonWidth",
@ -222,9 +228,10 @@ const c8 *const GUISkinSizeNames[EGDS_COUNT + 1] = {
"ButtonPressedTextOffsetY",
"ButtonPressedSpriteOffsetX",
"ButtonPressedSpriteOffsetY",
0,
0
};
enum EGUI_DEFAULT_TEXT
{
//! Text for the OK button on a message box
@ -249,7 +256,8 @@ enum EGUI_DEFAULT_TEXT
};
//! Names for default skin sizes
const c8 *const GUISkinTextNames[EGDT_COUNT + 1] = {
const c8* const GUISkinTextNames[EGDT_COUNT+1] =
{
"MessageBoxOkay",
"MessageBoxCancel",
"MessageBoxYes",
@ -258,7 +266,7 @@ const c8 *const GUISkinTextNames[EGDT_COUNT + 1] = {
"WindowButtonMaximize",
"WindowButtonMinimize",
"WindowButtonRestore",
0,
0
};
//! Customizable symbols for GUI
@ -316,7 +324,8 @@ enum EGUI_DEFAULT_ICON
EGDI_COUNT
};
const c8 *const GUISkinIconNames[EGDI_COUNT + 1] = {
const c8* const GUISkinIconNames[EGDI_COUNT+1] =
{
"windowMaximize",
"windowRestore",
"windowClose",
@ -340,7 +349,7 @@ const c8 *const GUISkinIconNames[EGDI_COUNT + 1] = {
"collapse",
"file",
"directory",
0,
0
};
// Customizable fonts
@ -361,19 +370,21 @@ enum EGUI_DEFAULT_FONT
EGDF_COUNT
};
const c8 *const GUISkinFontNames[EGDF_COUNT + 1] = {
const c8* const GUISkinFontNames[EGDF_COUNT+1] =
{
"defaultFont",
"buttonFont",
"windowFont",
"menuFont",
"tooltipFont",
0,
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;
@ -561,5 +572,9 @@ public:
virtual EGUI_SKIN_TYPE getType() const { return EGST_UNKNOWN; }
};
} // end namespace gui
} // end namespace irr
#endif

22
include/IGUISpriteBank.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_SPRITE_BANK_H_INCLUDED__
#define __I_GUI_SPRITE_BANK_H_INCLUDED__
#include "IReferenceCounted.h"
#include "irrArray.h"
@ -24,13 +25,12 @@ namespace gui
// 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() : textureNumber(0), rectNumber(0)
{
}
SGUISpriteFrame(u32 textureIndex, u32 positionIndex) :
textureNumber(textureIndex), rectNumber(positionIndex)
SGUISpriteFrame(u32 textureIndex, u32 positionIndex)
: textureNumber(textureIndex), rectNumber(positionIndex)
{
}
@ -45,10 +45,8 @@ struct SGUISpriteFrame
// 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)
SGUISprite() : frameTime(0) {}
SGUISprite(const SGUISpriteFrame& firstFrame) : frameTime(0)
{
Frames.push_back(firstFrame);
}
@ -57,6 +55,7 @@ struct SGUISprite
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.
@ -64,6 +63,7 @@ struct SGUISprite
class IGUISpriteBank : public virtual IReferenceCounted
{
public:
//! Returns the list of rectangles held by the sprite bank
virtual core::array< core::rect<s32> >& getPositions() = 0;
@ -134,5 +134,9 @@ public:
bool loop=true, bool center=false) = 0;
};
} // end namespace gui
} // end namespace irr
#endif // __I_GUI_SPRITE_BANK_H_INCLUDED__

16
include/IGUIStaticText.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_STATIC_TEXT_H_INCLUDED__
#define __I_GUI_STATIC_TEXT_H_INCLUDED__
#include "IGUIElement.h"
#include "SColor.h"
@ -17,9 +18,10 @@ class IGUIFont;
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) {}
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.
@ -86,9 +88,9 @@ public:
//! Sets text justification mode
/** \param horizontal: EGUIA_UPPERLEFT for left justified (default),
EGUIA_LOWERRIGHT for right justified, or EGUIA_CENTER for centered text.
EGUIA_LOWEERRIGHT 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. */
EGUIA_LOWEERRIGHT 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.
@ -129,5 +131,9 @@ public:
virtual bool isRightToLeft() const = 0;
};
} // end namespace gui
} // end namespace irr
#endif

25
include/IGUITabControl.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_TAB_CONTROL_H_INCLUDED__
#define __I_GUI_TAB_CONTROL_H_INCLUDED__
#include "IGUIElement.h"
#include "SColor.h"
@ -21,9 +22,10 @@ class IGUITab;
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) {}
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;
@ -122,9 +124,19 @@ public:
class IGUITab : public IGUIElement
{
public:
//! constructor
IGUITab(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_TAB, environment, parent, id, rectangle) {}
IGUITab(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
: IGUIElement(EGUIET_TAB, environment, parent, id, rectangle) {}
//! Returns zero based index of tab if in tabcontrol.
/** \deprecated Deprecated in 1.9, use IGUITabControl::getTabIndex instead*/
_IRR_DEPRECATED_ virtual s32 getNumber() const
{
if (Parent && Parent->getType() == EGUIET_TAB_CONTROL)
return static_cast<IGUITabControl*>(Parent)->getTabIndex(this);
return -1;
}
//! sets if the tab should draw its background
virtual void setDrawBackground(bool draw=true) = 0;
@ -147,3 +159,6 @@ public:
} // end namespace gui
} // end namespace irr
#endif

12
include/IGUIToolbar.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_GUI_TOOL_BAR_H_INCLUDED__
#define __I_GUI_TOOL_BAR_H_INCLUDED__
#include "IGUIElement.h"
@ -20,9 +21,10 @@ class IGUIButton;
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) {}
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,
@ -30,5 +32,9 @@ public:
bool isPushButton=false, bool useAlphaChannel=false) = 0;
};
} // end namespace gui
} // end namespace irr
#endif

232
include/IImage.h
View file

@ -2,13 +2,15 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_IMAGE_H_INCLUDED__
#define __I_IMAGE_H_INCLUDED__
#include "IReferenceCounted.h"
#include "position2d.h"
#include "rect.h"
#include "SColor.h"
#include <cstring>
#include "irrAllocator.h"
#include <string.h>
namespace irr
{
@ -23,9 +25,13 @@ NOTE: Floating point formats are not well supported yet. Basically only getData(
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)
#if defined(IRRLICHT_sRGB)
,Format_sRGB(1)
#endif
{
BytesPerPixel = getBitsPerPixelFromFormat(Format) / 8;
Pitch = BytesPerPixel * Size.Width;
@ -38,7 +44,7 @@ public:
delete[] Data;
if (DeleteMipMapsMemory)
delete[] MipMapsData;
Allocator.deallocate(MipMapsData);
}
//! Returns the color format
@ -47,6 +53,18 @@ public:
return Format;
}
#if defined(IRRLICHT_sRGB)
//! Texture is linear/sRGB (should be part of ColorFormat: default yes)
int get_sRGB() const
{
return Format_sRGB;
}
void set_sRGB(int val)
{
Format_sRGB = val;
}
#endif
//! Returns width and height of image data.
const core::dimension2d<u32>& getDimension() const
{
@ -87,7 +105,8 @@ public:
//! Returns mask for red value of a pixel
u32 getRedMask() const
{
switch (Format) {
switch (Format)
{
case ECF_A1R5G5B5:
return 0x1F << 10;
case ECF_R5G6B5:
@ -104,7 +123,8 @@ public:
//! Returns mask for green value of a pixel
u32 getGreenMask() const
{
switch (Format) {
switch (Format)
{
case ECF_A1R5G5B5:
return 0x1F << 5;
case ECF_R5G6B5:
@ -121,7 +141,8 @@ public:
//! Returns mask for blue value of a pixel
u32 getBlueMask() const
{
switch (Format) {
switch (Format)
{
case ECF_A1R5G5B5:
return 0x1F;
case ECF_R5G6B5:
@ -138,7 +159,8 @@ public:
//! Returns mask for alpha value of a pixel
u32 getAlphaMask() const
{
switch (Format) {
switch (Format)
{
case ECF_A1R5G5B5:
return 0x1 << 15;
case ECF_R5G6B5:
@ -162,6 +184,24 @@ public:
return Data;
}
//! Lock function. Use this to get a pointer to the image data.
/** Use getData instead.
\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. Be sure to call unlock() after
you don't need the pointer any more. */
_IRR_DEPRECATED_ void* lock()
{
return getData();
}
//! Unlock function.
/** Should be called after the pointer received by lock() is not
needed anymore. */
_IRR_DEPRECATED_ void unlock()
{
}
//! 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. */
@ -170,13 +210,15 @@ public:
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) {
while (i != mipmapLevel)
{
if (result.Width>1)
result.Width >>= 1;
if (result.Height>1)
@ -189,6 +231,7 @@ public:
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.
@ -196,12 +239,14 @@ public:
*/
void* getMipMapsData(irr::u32 mipLevel=1) const
{
if (MipMapsData && mipLevel > 0) {
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) {
while (i != mipLevel)
{
if (mipSize.Width > 1)
mipSize.Width >>= 1;
@ -230,26 +275,33 @@ public:
will by copied internally.
\param deleteMemory Whether the memory is deallocated upon
destruction. */
void setMipMapsData(void *data, bool ownForeignMemory)
void setMipMapsData(void* data, bool ownForeignMemory, bool deleteMemory)
{
if (data != MipMapsData) {
if (DeleteMipMapsMemory) {
delete[] MipMapsData;
if (data != MipMapsData)
{
if (DeleteMipMapsMemory)
{
Allocator.deallocate(MipMapsData);
DeleteMipMapsMemory = false;
}
if (data) {
if (ownForeignMemory) {
if (data)
{
if (ownForeignMemory)
{
MipMapsData = static_cast<u8*>(data);
DeleteMipMapsMemory = false;
} else {
DeleteMipMapsMemory = deleteMemory;
}
else
{
u32 dataSize = 0;
u32 width = Size.Width;
u32 height = Size.Height;
do {
do
{
if (width > 1)
width >>= 1;
@ -259,12 +311,14 @@ public:
dataSize += getDataSizeFromFormat(Format, width, height);
} while (width != 1 || height != 1);
MipMapsData = new u8[dataSize];
MipMapsData = Allocator.allocate(dataSize);
memcpy(MipMapsData, data, dataSize);
DeleteMipMapsMemory = true;
}
} else {
}
else
{
MipMapsData = 0;
}
}
@ -276,12 +330,6 @@ public:
//! 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;
@ -314,10 +362,24 @@ public:
//! fills the surface with given color
virtual void fill(const SColor &color) =0;
//! Inform whether the image is compressed
_IRR_DEPRECATED_ bool isCompressed() const
{
return IImage::isCompressedFormat(Format);
}
//! Check whether the image has MipMaps
/** \return True if image has MipMaps, else false. */
_IRR_DEPRECATED_ bool hasMipMaps() const
{
return (getMipMapsData() != 0);
}
//! get the amount of Bits per Pixel of the given color format
static u32 getBitsPerPixelFromFormat(const ECOLOR_FORMAT format)
{
switch (format) {
switch(format)
{
case ECF_A1R5G5B5:
return 16;
case ECF_R5G6B5:
@ -326,6 +388,28 @@ public:
return 24;
case ECF_A8R8G8B8:
return 32;
case ECF_DXT1:
return 16;
case ECF_DXT2:
case ECF_DXT3:
case ECF_DXT4:
case ECF_DXT5:
return 32;
case ECF_PVRTC_RGB2:
return 12;
case ECF_PVRTC_ARGB2:
case ECF_PVRTC2_ARGB2:
return 16;
case ECF_PVRTC_RGB4:
return 24;
case ECF_PVRTC_ARGB4:
case ECF_PVRTC2_ARGB4:
return 32;
case ECF_ETC1:
case ECF_ETC2_RGB:
return 24;
case ECF_ETC2_ARGB:
return 32;
case ECF_D16:
return 16;
case ECF_D32:
@ -360,23 +444,81 @@ public:
//! 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;
u32 imageSize = 0;
switch (format)
{
case ECF_DXT1:
imageSize = ((width + 3) / 4) * ((height + 3) / 4) * 8;
break;
case ECF_DXT2:
case ECF_DXT3:
case ECF_DXT4:
case ECF_DXT5:
imageSize = ((width + 3) / 4) * ((height + 3) / 4) * 16;
break;
case ECF_PVRTC_RGB2:
case ECF_PVRTC_ARGB2:
imageSize = (core::max_<u32>(width, 16) * core::max_<u32>(height, 8) * 2 + 7) / 8;
break;
case ECF_PVRTC_RGB4:
case ECF_PVRTC_ARGB4:
imageSize = (core::max_<u32>(width, 8) * core::max_<u32>(height, 8) * 4 + 7) / 8;
break;
case ECF_PVRTC2_ARGB2:
imageSize = core::ceil32(width / 8.0f) * core::ceil32(height / 4.0f) * 8;
break;
case ECF_PVRTC2_ARGB4:
case ECF_ETC1:
case ECF_ETC2_RGB:
imageSize = core::ceil32(width / 4.0f) * core::ceil32(height / 4.0f) * 8;
break;
case ECF_ETC2_ARGB:
imageSize = core::ceil32(width / 4.0f) * core::ceil32(height / 4.0f) * 16;
break;
default: // uncompressed formats
imageSize = getBitsPerPixelFromFormat(format) / 8 * width;
imageSize *= height;
break;
}
return imageSize;
}
// Define to check for all compressed image formats cases in a switch
#define IRR_CASE_IIMAGE_COMPRESSED_FORMAT\
case ECF_DXT1:\
case ECF_DXT2:\
case ECF_DXT3:\
case ECF_DXT4:\
case ECF_DXT5:\
case ECF_PVRTC_RGB2:\
case ECF_PVRTC_ARGB2:\
case ECF_PVRTC2_ARGB2:\
case ECF_PVRTC_RGB4:\
case ECF_PVRTC_ARGB4:\
case ECF_PVRTC2_ARGB4:\
case ECF_ETC1:\
case ECF_ETC2_RGB:\
case ECF_ETC2_ARGB:
//! check if this is compressed color format
static bool isCompressedFormat(const ECOLOR_FORMAT format)
{
switch(format)
{
IRR_CASE_IIMAGE_COMPRESSED_FORMAT
return true;
default:
return false;
}
}
//! check if the color format is only viable for depth/stencil textures
static bool isDepthFormat(const ECOLOR_FORMAT format)
{
switch (format) {
switch(format)
{
case ECF_D16:
case ECF_D32:
case ECF_D24S8:
@ -392,7 +534,8 @@ public:
if (isCompressedFormat(format))
return false;
switch (format) {
switch(format)
{
case ECF_R16F:
case ECF_G16R16F:
case ECF_A16B16G16R16F:
@ -406,6 +549,22 @@ public:
return false;
}
#if defined(PATCH_SUPERTUX_8_0_1_with_1_9_0)
static bool isRenderTargetOnlyFormat(const ECOLOR_FORMAT format)
{
switch (format)
{
case ECF_A1R5G5B5:
case ECF_R5G6B5:
case ECF_R8G8B8:
case ECF_A8R8G8B8:
return false;
default:
return true;
}
}
#endif
protected:
ECOLOR_FORMAT Format;
core::dimension2d<u32> Size;
@ -418,7 +577,16 @@ protected:
bool DeleteMemory;
bool DeleteMipMapsMemory;
core::irrAllocator<u8> Allocator;
#if defined(IRRLICHT_sRGB)
int Format_sRGB;
#endif
};
} // end namespace video
} // end namespace irr
#endif

19
include/IImageLoader.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_SURFACE_LOADER_H_INCLUDED__
#define __I_SURFACE_LOADER_H_INCLUDED__
#include "IReferenceCounted.h"
#include "IImage.h"
@ -27,6 +28,7 @@ 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.
@ -43,7 +45,22 @@ public:
/** \param file File handle to check.
\return Pointer to newly created image, or 0 upon error. */
virtual IImage* loadImage(io::IReadFile* file) const = 0;
//! Creates a multiple surfaces from the file eg. whole cube map.
/** \param file File handle to check.
\param type Pointer to E_TEXTURE_TYPE where a recommended type of the texture will be stored.
\return Array of pointers to newly created images. */
virtual core::array<IImage*> loadImages(io::IReadFile* file, E_TEXTURE_TYPE* type) const
{
core::array<IImage*> image;
return image;
}
};
} // end namespace video
} // end namespace irr
#endif

7
include/IImageWriter.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef _I_IMAGE_WRITER_H_INCLUDED__
#define _I_IMAGE_WRITER_H_INCLUDED__
#include "IReferenceCounted.h"
#include "irrString.h"
@ -19,6 +20,7 @@ namespace video
{
class IImage;
//! Interface for writing software image data.
class IImageWriter : public IReferenceCounted
{
@ -38,3 +40,6 @@ public:
} // namespace video
} // namespace irr
#endif // _I_IMAGE_WRITER_H_INCLUDED__

8
include/IIndexBuffer.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_INDEX_BUFFER_H_INCLUDED__
#define __I_INDEX_BUFFER_H_INCLUDED__
#include "IReferenceCounted.h"
#include "irrArray.h"
@ -23,6 +24,7 @@ namespace scene
class IIndexBuffer : public virtual IReferenceCounted
{
public:
virtual void* getData() =0;
virtual video::E_INDEX_TYPE getType() const =0;
@ -55,5 +57,9 @@ public:
virtual u32 getChangedID() const = 0;
};
} // end namespace scene
} // end namespace irr
#endif

31
include/ILogger.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_LOGGER_H_INCLUDED__
#define __I_LOGGER_H_INCLUDED__
#include "IReferenceCounted.h"
@ -18,7 +19,7 @@ enum ELOG_LEVEL
//! Used for printing information helpful in debugging
ELL_DEBUG,
//! Useful information to print. For example hardware info or something started/stopped.
//! Useful information to print. For example hardware infos or something started/stopped.
ELL_INFORMATION,
//! Warnings that something isn't as expected and can cause oddities
@ -32,10 +33,12 @@ enum ELOG_LEVEL
ELL_NONE
};
//! Interface for logging messages, warnings and errors
class ILogger : public virtual IReferenceCounted
{
public:
//! Destructor
virtual ~ILogger() {}
@ -70,6 +73,30 @@ public:
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;
virtual void log(const c8* text, const wchar_t* hint, 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 wchar_t* text, const wchar_t* hint, ELOG_LEVEL ll=ELL_INFORMATION) = 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 wchar_t* text, ELOG_LEVEL ll=ELL_INFORMATION) = 0;
};
} // end namespace
#endif

8
include/IMaterialRenderer.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_MATERIAL_RENDERER_H_INCLUDED__
#define __I_MATERIAL_RENDERER_H_INCLUDED__
#include "IReferenceCounted.h"
#include "SMaterial.h"
@ -24,6 +25,7 @@ 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
@ -97,5 +99,9 @@ public:
virtual IShaderConstantSetCallBack* getShaderConstantSetCallBack() const { return 0; }
};
} // end namespace video
} // end namespace irr
#endif

85
include/IMaterialRendererServices.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_MATERIAL_RENDERER_SERVICES_H_INCLUDED__
#define __I_MATERIAL_RENDERER_SERVICES_H_INCLUDED__
#include "SMaterial.h"
#include "S3DVertex.h"
@ -14,10 +15,12 @@ namespace video
class IVideoDriver;
//! Interface providing some methods for changing advanced, internal states of a IVideoDriver.
class IMaterialRendererServices
{
public:
//! Destructor
virtual ~IMaterialRendererServices() {}
@ -35,11 +38,30 @@ public:
const SMaterial& lastMaterial,
bool resetAllRenderstates) = 0;
//! Return an index constant for the vertex shader based on a uniform variable name.
//! Return an index constant for the vertex shader based on a 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)
//! Sets a constant for the vertex shader based on a name.
/** This can be used if you used a high level shader language like GLSL
or HLSL to create a shader. Example: If you created a shader which has
variables named 'mWorldViewProj' (containing the WorldViewProjection
matrix) and another one named 'fTime' containing one float, you can set
them in your IShaderConstantSetCallBack derived class like this:
\code
virtual void OnSetConstants(video::IMaterialRendererServices* services, s32 userData)
{
video::IVideoDriver* driver = services->getVideoDriver();
f32 time = (f32)os::Timer::getTime()/100000.0f;
services->setVertexShaderConstant("fTime", &time, 1);
core::matrix4 worldViewProj(driver->getTransform(video::ETS_PROJECTION));
worldViewProj *= driver->getTransform(video::ETS_VIEW);
worldViewProj *= driver->getTransform(video::ETS_WORLD);
services->setVertexShaderConstant("mWorldViewProj", worldViewProj.M, 16);
}
\endcode
\param index Index of the variable
\param floats Pointer to array of floats
\param count Amount of floats in array.
\return True if successful.
@ -50,16 +72,27 @@ public:
virtual bool setVertexShaderConstant(s32 index, const s32* ints, int count) = 0;
//! Uint interface for the above.
/* NOTE: UINT only works with GLSL, not supported for other shaders.
Also GLES drivers in Irrlicht do not support it as this needs at least GLES 3.0.
*/
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
//! Sets a vertex shader constant.
/** Can be used if you created a shader using pixel/vertex shader
assembler or ARB_fragment_program or ARB_vertex_program.
\param data: Data to be set in the constants
\param startRegister: First register to be set
\param constantAmount: Amount of registers to be set. One register consists of 4 floats. */
virtual void setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1) = 0;
//! Return an index constant for the pixel shader based on a name.
virtual s32 getPixelShaderConstantID(const c8* name) = 0;
//! Sets a value for the given pixel shader uniform variable
//! Sets a constant for the pixel shader based on a name.
/** 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 index Index of the variable
\param floats Pointer to array of floats
\param count Amount of floats in array.
\return True if successful. */
@ -69,8 +102,43 @@ public:
virtual bool setPixelShaderConstant(s32 index, const s32* ints, int count) = 0;
//! Uint interface for the above.
/* NOTE: UINT only works with GLSL, not supported for other shaders.
Also GLES drivers in Irrlicht do not support it as this needs at least GLES 3.0.
*/
virtual bool setPixelShaderConstant(s32 index, const u32* ints, int count) = 0;
//! Sets a pixel shader constant.
/** Can be used if you created a shader using pixel/vertex shader
assembler or ARB_fragment_program or ARB_vertex_program.
\param data Data to be set in the constants
\param startRegister First register to be set.
\param constantAmount Amount of registers to be set. One register consists of 4 floats. */
virtual void setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1) = 0;
//! \deprecated. This method may be removed by Irrlicht 2.0
_IRR_DEPRECATED_ bool setVertexShaderConstant(const c8* name, const f32* floats, int count)
{
return setVertexShaderConstant(getVertexShaderConstantID(name), floats, count);
}
//! \deprecated. This method may be removed by Irrlicht 2.0
_IRR_DEPRECATED_ bool setVertexShaderConstant(const c8* name, const s32* ints, int count)
{
return setVertexShaderConstant(getVertexShaderConstantID(name), ints, count);
}
//! \deprecated. This method may be removed by Irrlicht 2.0
_IRR_DEPRECATED_ bool setPixelShaderConstant(const c8* name, const f32* floats, int count)
{
return setPixelShaderConstant(getPixelShaderConstantID(name), floats, count);
}
//! \deprecated. This method may be removed by Irrlicht 2.0
_IRR_DEPRECATED_ bool setPixelShaderConstant(const c8* name, const s32* ints, int count)
{
return setPixelShaderConstant(getPixelShaderConstantID(name), ints, count);
}
//! Get pointer to the IVideoDriver interface
/** \return Pointer to the IVideoDriver interface */
virtual IVideoDriver* getVideoDriver() = 0;
@ -78,3 +146,6 @@ public:
} // end namespace video
} // end namespace irr
#endif

6
include/IMemoryReadFile.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_MEMORY_READ_FILE_H_INCLUDED__
#define __I_MEMORY_READ_FILE_H_INCLUDED__
#include "IReadFile.h"
@ -25,3 +26,6 @@ public:
};
} // end namespace io
} // end namespace irr
#endif

13
include/IMesh.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_MESH_H_INCLUDED__
#define __I_MESH_H_INCLUDED__
#include "IReferenceCounted.h"
#include "SMaterial.h"
@ -59,6 +60,7 @@ enum E_ANIMATED_MESH_TYPE
EAMT_STATIC
};
class IMeshBuffer;
//! Class which holds the geometry of an object.
@ -69,6 +71,7 @@ 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;
@ -94,6 +97,11 @@ public:
/** \param box New bounding box to use for the mesh. */
virtual void setBoundingBox( const core::aabbox3df& box) = 0;
//! Sets a flag of all contained materials to a new value.
/** \param flag: Flag to set in all materials.
\param newvalue: New value to set in all materials. */
virtual void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue) = 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
@ -121,3 +129,6 @@ public:
} // end namespace scene
} // end namespace irr
#endif

42
include/IMeshBuffer.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_MESH_BUFFER_H_INCLUDED__
#define __I_MESH_BUFFER_H_INCLUDED__
#include "IReferenceCounted.h"
#include "SMaterial.h"
@ -38,6 +39,7 @@ 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;
@ -118,6 +120,11 @@ public:
\param numIndices Number of indices in array. */
virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) = 0;
//! Append the meshbuffer to the current buffer
/** Only works for compatible vertex types
\param other Buffer to append to this one. */
virtual void append(const IMeshBuffer* const other) = 0;
//! get the current hardware mapping hint
virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const = 0;
@ -156,27 +163,26 @@ public:
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;
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_QUAD_STRIP: return (indexCount-2)/2;
case scene::EPT_QUADS: return indexCount/4;
case scene::EPT_POLYGON: return indexCount; // (not really primitives, that would be 1, works like line_strip)
case scene::EPT_POINT_SPRITES: return indexCount;
}
return 0;
}
};
} // end namespace scene
} // end namespace irr
#endif

48
include/IMeshCache.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_MESH_CACHE_H_INCLUDED__
#define __I_MESH_CACHE_H_INCLUDED__
#include "IReferenceCounted.h"
#include "path.h"
@ -26,6 +27,7 @@ to remove them and to iterate through already loaded meshes. */
class IMeshCache : public virtual IReferenceCounted
{
public:
//! Destructor
virtual ~IMeshCache() {}
@ -76,6 +78,46 @@ public:
number. */
virtual IAnimatedMesh* getMeshByIndex(u32 index) = 0;
//! Returns a mesh based on its name (often a filename).
/** \deprecated Use getMeshByName() instead. This method may be removed by
Irrlicht 1.9 */
_IRR_DEPRECATED_ IAnimatedMesh* getMeshByFilename(const io::path& filename)
{
return getMeshByName(filename);
}
//! Get the name of a loaded mesh, based on its index. (Name is often identical to the filename).
/** \deprecated Use getMeshName() instead. This method may be removed by
Irrlicht 1.9 */
_IRR_DEPRECATED_ const io::path& getMeshFilename(u32 index) const
{
return getMeshName(index).getInternalName();
}
//! Get the name of a loaded mesh, if there is any. (Name is often identical to the filename).
/** \deprecated Use getMeshName() instead. This method may be removed by
Irrlicht 1.9 */
_IRR_DEPRECATED_ const io::path& getMeshFilename(const IMesh* const mesh) const
{
return getMeshName(mesh).getInternalName();
}
//! Renames a loaded mesh.
/** \deprecated Use renameMesh() instead. This method may be removed by
Irrlicht 1.9 */
_IRR_DEPRECATED_ bool setMeshFilename(u32 index, const io::path& filename)
{
return renameMesh(index, filename);
}
//! Renames a loaded mesh.
/** \deprecated Use renameMesh() instead. This method may be removed by
Irrlicht 1.9 */
_IRR_DEPRECATED_ bool setMeshFilename(const IMesh* const mesh, const io::path& filename)
{
return renameMesh(mesh, filename);
}
//! 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. */
@ -127,5 +169,9 @@ public:
virtual void clearUnusedMeshes() = 0;
};
} // end namespace scene
} // end namespace irr
#endif

7
include/IMeshLoader.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_MESH_LOADER_H_INCLUDED__
#define __I_MESH_LOADER_H_INCLUDED__
#include "IReferenceCounted.h"
#include "path.h"
@ -25,6 +26,7 @@ ISceneManager::addExternalMeshLoader() to the engine. */
class IMeshLoader : public virtual IReferenceCounted
{
public:
//! Constructor
IMeshLoader() {}
@ -46,5 +48,8 @@ public:
virtual IAnimatedMesh* createMesh(io::IReadFile* file) = 0;
};
} // end namespace scene
} // end namespace irr
#endif

41
include/IMeshManipulator.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_MESH_MANIPULATOR_H_INCLUDED__
#define __I_MESH_MANIPULATOR_H_INCLUDED__
#include "IReferenceCounted.h"
#include "vector3d.h"
@ -28,6 +29,7 @@ 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.
@ -98,6 +100,7 @@ public:
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.
@ -110,9 +113,11 @@ public:
return true;
bool result = true;
core::aabbox3df bufferbox;
for (u32 i = 0; i < mesh->getMeshBufferCount(); ++i) {
for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
{
result &= apply(func, mesh->getMeshBuffer(i), boundingBoxUpdate);
if (boundingBoxUpdate) {
if (boundingBoxUpdate)
{
if (0==i)
bufferbox.reset(mesh->getMeshBuffer(i)->getBoundingBox());
else
@ -138,22 +143,31 @@ protected:
return true;
core::aabbox3df bufferbox;
for (u32 i = 0; i < buffer->getVertexCount(); ++i) {
switch (buffer->getVertexType()) {
case video::EVT_STANDARD: {
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: {
}
break;
case video::EVT_2TCOORDS:
{
video::S3DVertex2TCoords* verts = (video::S3DVertex2TCoords*)buffer->getVertices();
func(verts[i]);
} break;
case video::EVT_TANGENTS: {
}
break;
case video::EVT_TANGENTS:
{
video::S3DVertexTangents* verts = (video::S3DVertexTangents*)buffer->getVertices();
func(verts[i]);
} break;
}
if (boundingBoxUpdate) {
break;
}
if (boundingBoxUpdate)
{
if (0==i)
bufferbox.reset(buffer->getPosition(0));
else
@ -168,3 +182,6 @@ protected:
} // end namespace scene
} // end namespace irr
#endif

13
include/IMeshSceneNode.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_MESH_SCENE_NODE_H_INCLUDED__
#define __I_MESH_SCENE_NODE_H_INCLUDED__
#include "ISceneNode.h"
@ -13,18 +14,20 @@ 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) {}
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. */
@ -48,3 +51,7 @@ public:
} // end namespace scene
} // end namespace irr
#endif

58
include/IMeshWriter.h Normal file
View file

@ -0,0 +1,58 @@
// 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
#ifndef __IRR_I_MESH_WRITER_H_INCLUDED__
#define __IRR_I_MESH_WRITER_H_INCLUDED__
#include "IReferenceCounted.h"
#include "EMeshWriterEnums.h"
namespace irr
{
namespace io
{
class IWriteFile;
} // end namespace io
namespace scene
{
class IMesh;
//! Interface for writing meshes
class IMeshWriter : public virtual IReferenceCounted
{
public:
//! Destructor
virtual ~IMeshWriter() {}
//! Get the type of the mesh writer
/** For own implementations, use MAKE_IRR_ID as shown in the
EMESH_WRITER_TYPE enumeration to return your own unique mesh
type id.
\return Type of the mesh writer. */
virtual EMESH_WRITER_TYPE getType() const = 0;
//! Write a static mesh.
/** \param file File handle to write the mesh to.
\param mesh Pointer to mesh to be written.
\param flags Optional flags to set properties of the writer.
\return True if successful */
virtual bool writeMesh(io::IWriteFile* file, scene::IMesh* mesh,
s32 flags=EMWF_NONE) = 0;
// Writes an animated mesh
// for future use, only b3d writer is able to write animated meshes currently and that was implemented using the writeMesh above.
/* \return Returns true if successful */
//virtual bool writeAnimatedMesh(io::IWriteFile* file,
// scene::IAnimatedMesh* mesh,
// s32 flags=EMWF_NONE) = 0;
};
} // end namespace
} // end namespace
#endif

30
include/IOSOperator.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_OS_OPERATOR_H_INCLUDED__
#define __I_OS_OPERATOR_H_INCLUDED__
#include "IReferenceCounted.h"
#include "irrString.h"
@ -10,36 +11,35 @@
namespace irr
{
//! The OSOperator provides OS-specific methods and information.
//! The Operating system operator provides operation system specific methods and information.
class IOSOperator : public virtual IReferenceCounted
{
public:
//! Get the current OS version as string.
//! Get the current operation system version as string.
virtual const core::stringc& getOperatingSystemVersion() const = 0;
//! Get the current operation system version as string.
/** \deprecated Use getOperatingSystemVersion instead. This method will be removed in Irrlicht 1.9. */
_IRR_DEPRECATED_ const wchar_t* getOperationSystemVersion() const
{
return core::stringw(getOperatingSystemVersion()).c_str();
}
//! 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.
/** \return Returns 0 if no string is in there. */
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
#endif

480
include/IProfiler.h Normal file
View file

@ -0,0 +1,480 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
// Written by Michael Zeilfelder
#ifndef __I_PROFILER_H_INCLUDED__
#define __I_PROFILER_H_INCLUDED__
#include "IrrCompileConfig.h"
#include "irrString.h"
#include "irrArray.h"
#include "ITimer.h"
#include <limits.h> // for INT_MAX (we should have a S32_MAX...)
namespace irr
{
class ITimer;
//! Used to store the profile data (and also used for profile group data).
struct SProfileData
{
friend class IProfiler;
SProfileData()
{
GroupIndex = 0;
reset();
}
bool operator<(const SProfileData& pd) const
{
return Id < pd.Id;
}
bool operator==(const SProfileData& pd) const
{
return Id == pd.Id;
}
u32 getGroupIndex() const
{
return GroupIndex;
}
const core::stringw& getName() const
{
return Name;
}
//! Each time profiling for this data is stopped it increases the counter by 1.
u32 getCallsCounter() const
{
return CountCalls;
}
//! Longest time a profile call for this id took from start until it was stopped again.
u32 getLongestTime() const
{
return LongestTime;
}
//! Time spend between start/stop
u32 getTimeSum() const
{
return TimeSum;
}
private:
// just to be used for searching as it does no initialization besides id
SProfileData(u32 id) : Id(id) {}
void reset()
{
CountCalls = 0;
LongestTime = 0;
TimeSum = 0;
LastTimeStarted = 0;
StartStopCounter = 0;
}
s32 Id;
u32 GroupIndex;
core::stringw Name;
s32 StartStopCounter; // 0 means stopped > 0 means it runs.
u32 CountCalls;
u32 LongestTime;
u32 TimeSum;
u32 LastTimeStarted;
};
//! Code-profiler. Please check the example in the Irrlicht examples folder about how to use it.
// Implementer notes:
// The design is all about allowing to use the central start/stop mechanism with minimal time overhead.
// This is why the class works without a virtual functions interface contrary to the usual Irrlicht design.
// And also why it works with id's instead of strings in the start/stop functions even if it makes using
// the class slightly harder.
// The class comes without reference-counting because the profiler instance is never released (TBD).
class IProfiler
{
public:
//! Constructor. You could use this to create a new profiler, but usually getProfiler() is used to access the global instance.
IProfiler() : Timer(0), NextAutoId(INT_MAX)
{}
virtual ~IProfiler()
{}
//! Add an id with given name and group which can be used for profiling with start/stop
/** After calling this once you can start/stop profiling for the given id.
\param id: Should be >= 0 as negative id's are reserved for Irrlicht. Also very large numbers (near INT_MAX) might
have been added automatically by the other add function.
\param name: Name for displaying profile data.
\param groupName: Each id belongs into a group - this helps on displaying profile data. */
inline void add(s32 id, const core::stringw &name, const core::stringw &groupName);
//! Add an automatically generated for the given name and group which can be used for profiling with start/stop.
/** After calling this once you can start/stop profiling with the returned id.
\param name: Name for displaying profile data.
\param groupName: Each id belongs into a group - this helps on displaying profile data.
\return Automatic id's start at INT_MAX and count down for each new id. If the name already has an id then that id will be returned. */
inline s32 add(const core::stringw &name, const core::stringw &groupName);
//! Return the number of profile data blocks. There is one for each id.
u32 getProfileDataCount() const
{
return ProfileDatas.size();
}
//! Search for the index of the profile data by name
/** \param result Receives the resulting data index when one was found.
\param name String with name to search for
\return true when found, false when not found */
inline bool findDataIndex(u32 & result, const core::stringw &name) const;
//! Get the profile data
/** \param index A value between 0 and getProfileDataCount()-1. Indices can change when new id's are added.*/
const SProfileData& getProfileDataByIndex(u32 index) const
{
return ProfileDatas[index];
}
//! Get the profile data
/** \param id Same value as used in ::add
\return Profile data for the given id or 0 when it does not exist. */
inline const SProfileData* getProfileDataById(u32 id);
//! Get the number of profile groups. Will be at least 1.
/** NOTE: The first groups is always L"overview" which is an overview for all existing groups */
inline u32 getGroupCount() const
{
return ProfileGroups.size();
}
//! Get profile data for a group.
/** NOTE: The first groups is always L"overview" which is an overview for all existing groups */
inline const SProfileData& getGroupData(u32 index) const
{
return ProfileGroups[index];
}
//! Find the group index by the group-name
/** \param result Receives the resulting group index when one was found.
\param name String with name to search for
\return true when found, false when not found */
inline bool findGroupIndex(u32 & result, const core::stringw &name) const;
//! Start profile-timing for the given id
/** This increases an internal run-counter for the given id. It will profile as long as that counter is > 0.
NOTE: you have to add the id first with one of the ::add functions
*/
inline void start(s32 id);
//! Stop profile-timing for the given id
/** This increases an internal run-counter for the given id. If it reaches 0 the time since start is recorded.
You should have the same amount of start and stop calls. If stop is called more often than start
then the additional stop calls will be ignored (counter never goes below 0)
*/
inline void stop(s32 id);
//! Reset profile data for the given id
inline void resetDataById(s32 id);
//! Reset profile data for the given index
inline void resetDataByIndex(u32 index);
//! Reset profile data for a whole group
inline void resetGroup(u32 index);
//! Reset all profile data
/** NOTE: This is not deleting id's or groups, just resetting all timers to 0. */
inline void resetAll();
//! Write all profile-data into a string
/** \param result Receives the result string.
\param includeOverview When true a group-overview is attached first
\param suppressUncalled When true elements which got never called are not printed */
virtual void printAll(core::stringw &result, bool includeOverview=false,bool suppressUncalled=true) const = 0;
//! Write the profile data of one group into a string
/** \param result Receives the result string.
\param groupIndex_ */
virtual void printGroup(core::stringw &result, u32 groupIndex, bool suppressUncalled) const = 0;
protected:
inline u32 addGroup(const core::stringw &name);
// I would prefer using os::Timer, but os.h is not in the public interface so far.
// Timer must be initialized by the implementation.
ITimer * Timer;
core::array<SProfileData> ProfileDatas;
core::array<SProfileData> ProfileGroups;
private:
s32 NextAutoId; // for giving out id's automatically
};
//! Access the Irrlicht profiler object.
/** Profiler is always accessible, except in destruction of global objects.
If you want to get internal profiling information about the engine itself
you will have to re-compile the engine with _IRR_COMPILE_WITH_PROFILING_ enabled.
But you can use the profiler for profiling your own projects without that. */
IRRLICHT_API IProfiler& IRRCALLCONV getProfiler();
//! Class where the objects profile their own life-time.
/** This is a comfort wrapper around the IProfiler start/stop mechanism which is easier to use
when you want to profile a scope. You only have to create an object and it will profile it's own lifetime
for the given id. */
class CProfileScope
{
public:
//! Construct with an known id.
/** This is the fastest scope constructor, but the id must have been added before.
\param id Any id which you did add to the profiler before. */
CProfileScope(s32 id)
: Id(id), Profiler(getProfiler())
{
Profiler.start(Id);
}
//! Object will create the given name, groupName combination for the id if it doesn't exist already
/** \param id: Should be >= 0 as negative id's are reserved for Irrlicht. Also very large numbers (near INT_MAX) might
have been created already by the automatic add function of ::IProfiler.
\param name: Name for displaying profile data.
\param groupName: Each id belongs into a group - this helps on displaying profile data. */
CProfileScope(s32 id, const core::stringw &name, const core::stringw &groupName)
: Id(id), Profiler(getProfiler())
{
Profiler.add(Id, name, groupName);
Profiler.start(Id);
}
//! Object will create an id for the given name, groupName combination if they don't exist already
/** Slowest scope constructor, but usually still fine unless speed is very critical.
\param name: Name for displaying profile data.
\param groupName: Each id belongs into a group - this helps on displaying profile data. */
CProfileScope(const core::stringw &name, const core::stringw &groupName)
: Profiler(getProfiler())
{
Id = Profiler.add(name, groupName);
Profiler.start(Id);
}
~CProfileScope()
{
Profiler.stop(Id);
}
protected:
s32 Id;
IProfiler& Profiler;
};
// IMPLEMENTATION for in-line stuff
void IProfiler::start(s32 id)
{
s32 idx = ProfileDatas.binary_search(SProfileData(id));
if ( idx >= 0 && Timer )
{
++ProfileDatas[idx].StartStopCounter;
if (ProfileDatas[idx].StartStopCounter == 1 )
ProfileDatas[idx].LastTimeStarted = Timer->getRealTime();
}
}
void IProfiler::stop(s32 id)
{
if ( Timer )
{
u32 timeNow = Timer->getRealTime();
s32 idx = ProfileDatas.binary_search(SProfileData(id));
if ( idx >= 0 )
{
SProfileData &data = ProfileDatas[idx];
--ProfileDatas[idx].StartStopCounter;
if ( data.LastTimeStarted != 0 && ProfileDatas[idx].StartStopCounter == 0)
{
// update data for this id
++data.CountCalls;
u32 diffTime = timeNow - data.LastTimeStarted;
data.TimeSum += diffTime;
if ( diffTime > data.LongestTime )
data.LongestTime = diffTime;
data.LastTimeStarted = 0;
// update data of it's group
SProfileData & group = ProfileGroups[data.GroupIndex];
++group.CountCalls;
group.TimeSum += diffTime;
if ( diffTime > group.LongestTime )
group.LongestTime = diffTime;
group.LastTimeStarted = 0;
}
else if ( ProfileDatas[idx].StartStopCounter < 0 )
{
// ignore additional stop calls
ProfileDatas[idx].StartStopCounter = 0;
}
}
}
}
s32 IProfiler::add(const core::stringw &name, const core::stringw &groupName)
{
u32 index;
if ( findDataIndex(index, name) )
{
add( ProfileDatas[index].Id, name, groupName );
return ProfileDatas[index].Id;
}
else
{
s32 id = NextAutoId;
--NextAutoId;
add( id, name, groupName );
return id;
}
}
void IProfiler::add(s32 id, const core::stringw &name, const core::stringw &groupName)
{
u32 groupIdx;
if ( !findGroupIndex(groupIdx, groupName) )
{
groupIdx = addGroup(groupName);
}
SProfileData data(id);
s32 idx = ProfileDatas.binary_search(data);
if ( idx < 0 )
{
data.reset();
data.GroupIndex = groupIdx;
data.Name = name;
ProfileDatas.push_back(data);
ProfileDatas.sort();
}
else
{
// only reset on group changes, otherwise we want to keep the data or coding CProfileScope would become tricky.
if ( groupIdx != ProfileDatas[idx].GroupIndex )
{
resetDataByIndex((u32)idx);
ProfileDatas[idx].GroupIndex = groupIdx;
}
ProfileDatas[idx].Name = name;
}
}
u32 IProfiler::addGroup(const core::stringw &name)
{
SProfileData group;
group.Id = -1; // Id for groups doesn't matter so far
group.Name = name;
ProfileGroups.push_back(group);
return ProfileGroups.size()-1;
}
bool IProfiler::findDataIndex(u32 & result, const core::stringw &name) const
{
for ( u32 i=0; i < ProfileDatas.size(); ++i )
{
if ( ProfileDatas[i].Name == name )
{
result = i;
return true;
}
}
return false;
}
const SProfileData* IProfiler::getProfileDataById(u32 id)
{
SProfileData data(id);
s32 idx = ProfileDatas.binary_search(data);
if ( idx >= 0 )
return &ProfileDatas[idx];
return NULL;
}
bool IProfiler::findGroupIndex(u32 & result, const core::stringw &name) const
{
for ( u32 i=0; i < ProfileGroups.size(); ++i )
{
if ( ProfileGroups[i].Name == name )
{
result = i;
return true;
}
}
return false;
}
void IProfiler::resetDataById(s32 id)
{
s32 idx = ProfileDatas.binary_search(SProfileData(id));
if ( idx >= 0 )
{
resetDataByIndex((u32)idx);
}
}
void IProfiler::resetDataByIndex(u32 index)
{
SProfileData &data = ProfileDatas[index];
SProfileData & group = ProfileGroups[data.GroupIndex];
group.CountCalls -= data.CountCalls;
group.TimeSum -= data.TimeSum;
data.reset();
}
//! Reset profile data for a whole group
void IProfiler::resetGroup(u32 index)
{
for ( u32 i=0; i<ProfileDatas.size(); ++i )
{
if ( ProfileDatas[i].GroupIndex == index )
ProfileDatas[i].reset();
}
if ( index < ProfileGroups.size() )
ProfileGroups[index].reset();
}
void IProfiler::resetAll()
{
for ( u32 i=0; i<ProfileDatas.size(); ++i )
{
ProfileDatas[i].reset();
}
for ( u32 i=0; i<ProfileGroups.size(); ++i )
{
ProfileGroups[i].reset();
}
}
//! For internal engine use:
//! Code inside IRR_PROFILE is only executed when _IRR_COMPILE_WITH_PROFILING_ is set
//! This allows disabling all profiler code completely by changing that define.
//! It's generally useful to wrap profiler-calls in application code with a similar macro.
#ifdef _IRR_COMPILE_WITH_PROFILING_
#define IRR_PROFILE(X) X
#else
#define IRR_PROFILE(X)
#endif // IRR_PROFILE
} // namespace irr
#endif // __I_PROFILER_H_INCLUDED__

6
include/IReadFile.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_READ_FILE_H_INCLUDED__
#define __I_READ_FILE_H_INCLUDED__
#include "IReferenceCounted.h"
#include "coreutil.h"
@ -55,3 +56,6 @@ IReadFile *createLimitReadFile(const io::path &fileName, IReadFile *alreadyOpene
} // end namespace io
} // end namespace irr
#endif

26
include/IReferenceCounted.h
View file

@ -2,10 +2,15 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_IREFERENCE_COUNTED_H_INCLUDED__
#define __I_IREFERENCE_COUNTED_H_INCLUDED__
#include "irrTypes.h"
#ifdef _IRR_COMPILE_WITH_LEAK_HUNTER_
#include "leakHunter.h"
#endif
namespace irr
{
@ -40,15 +45,22 @@ is stored somewhere by the driver.
class IReferenceCounted
{
public:
//! Constructor.
IReferenceCounted() :
DebugName(0), ReferenceCounter(1)
IReferenceCounted()
: DebugName(0), ReferenceCounter(1)
{
#ifdef _IRR_COMPILE_WITH_LEAK_HUNTER_
LeakHunter::addObject(this);
#endif
}
//! Destructor.
virtual ~IReferenceCounted()
{
#ifdef _IRR_COMPILE_WITH_LEAK_HUNTER_
LeakHunter::removeObject(this);
#endif
}
//! Grabs the object. Increments the reference counter by one.
@ -117,7 +129,8 @@ public:
_IRR_DEBUG_BREAK_IF(ReferenceCounter <= 0)
--ReferenceCounter;
if (!ReferenceCounter) {
if (!ReferenceCounter)
{
delete this;
return true;
}
@ -142,6 +155,7 @@ public:
}
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.
@ -152,6 +166,7 @@ protected:
}
private:
//! The debug name.
const c8* DebugName;
@ -160,3 +175,6 @@ private:
};
} // end namespace irr
#endif

24
include/IRenderTarget.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_RENDER_TARGET_H_INCLUDED__
#define __I_RENDER_TARGET_H_INCLUDED__
#include "IReferenceCounted.h"
#include "EDriverTypes.h"
@ -29,9 +30,9 @@ enum E_CUBE_SURFACE
class IRenderTarget : public virtual IReferenceCounted
{
public:
//! constructor
IRenderTarget() :
DepthStencil(0), DriverType(EDT_NULL)
IRenderTarget() : DepthStencil(0), DriverType(EDT_NULL)
{
}
@ -69,9 +70,12 @@ public:
//! You can pass getDepthStencil() for depthStencil if you don't want to change that one
void setTexture(ITexture* texture, ITexture* depthStencil)
{
if (texture) {
if ( texture )
{
setTextures(&texture, 1, depthStencil);
} else {
}
else
{
setTextures(0, 0, depthStencil);
}
}
@ -79,9 +83,12 @@ public:
//! Set one cube surface texture.
void setTexture(ITexture* texture, ITexture* depthStencil, E_CUBE_SURFACE cubeSurface)
{
if (texture) {
if ( texture )
{
setTextures(&texture, 1, depthStencil, &cubeSurface, 1);
} else {
}
else
{
setTextures(0, 0, depthStencil, &cubeSurface, 1);
}
}
@ -93,6 +100,7 @@ public:
}
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;
@ -117,3 +125,5 @@ private:
}
}
#endif

7
include/ISceneCollisionManager.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_SCENE_COLLISION_MANAGER_H_INCLUDED__
#define __I_SCENE_COLLISION_MANAGER_H_INCLUDED__
#include "IReferenceCounted.h"
#include "position2d.h"
@ -18,6 +19,7 @@ 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
@ -27,7 +29,10 @@ public:
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
#endif

41
include/ISceneManager.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_SCENE_MANAGER_H_INCLUDED__
#define __I_SCENE_MANAGER_H_INCLUDED__
#include "IReferenceCounted.h"
#include "irrArray.h"
@ -12,6 +13,7 @@
#include "dimension2d.h"
#include "SColor.h"
#include "ESceneNodeTypes.h"
#include "EMeshWriterEnums.h"
#include "SceneParameters.h"
#include "ISkinnedMesh.h"
@ -107,6 +109,7 @@ class ISceneCollisionManager;
class IMeshLoader;
class IMeshManipulator;
class IMeshSceneNode;
class IMeshWriter;
class ISceneNode;
class ISceneNodeFactory;
@ -126,7 +129,8 @@ 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.
//! Get pointer to an animateable 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:
@ -314,10 +318,20 @@ public:
* \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.
* \param filename: Filename of the mesh to load.
* \param alternativeCacheName: In case you want to have the mesh under another name in the cache (to create real copies)
* \return Null if failed, otherwise pointer to the mesh.
* This pointer should not be dropped. See IReferenceCounted::drop() for more information.
**/
virtual IAnimatedMesh* getMesh(const io::path& filename, const io::path& alternativeCacheName=io::path("")) = 0;
//! Get pointer to an animateable mesh. Loads the file if not loaded already.
/** Works just as getMesh(const char* filename). If you want to
remove a loaded mesh from the cache again, use removeMesh().
\param file File handle of the mesh to load.
\return NULL if failed and pointer to the mesh if successful.
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.
@ -331,6 +345,16 @@ public:
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual video::IVideoDriver* getVideoDriver() = 0;
//! Get the active GUIEnvironment
/** \return Pointer to the GUIEnvironment
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual gui::IGUIEnvironment* getGUIEnvironment() = 0;
//! Get the active FileSystem
/** \return Pointer to the FileSystem
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual io::IFileSystem* getFileSystem() = 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.
@ -505,7 +529,7 @@ public:
//! 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.
after rendering them. But sometimes you might have to manully reset this.
For example when you deleted nodes between registering and rendering. */
virtual void clearAllRegisteredNodesForRendering() = 0;
@ -599,6 +623,11 @@ public:
See IReferenceCounted::drop() for more information. */
virtual ISceneManager* createNewSceneManager(bool cloneContent=false) = 0;
//! Get a mesh writer implementation if available
/** Note: You need to drop() the pointer after use again, see IReferenceCounted::drop()
for details. */
virtual IMeshWriter* createMeshWriter(EMESH_WRITER_TYPE type) = 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. */
@ -628,5 +657,9 @@ public:
virtual bool isCulled(const ISceneNode* node) const =0;
};
} // end namespace scene
} // end namespace irr
#endif

176
include/ISceneNode.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_SCENE_NODE_H_INCLUDED__
#define __I_SCENE_NODE_H_INCLUDED__
#include "IReferenceCounted.h"
#include "ESceneNodeTypes.h"
@ -13,9 +14,7 @@
#include "aabbox3d.h"
#include "matrix4.h"
#include "IAttributes.h"
#include <list>
#include <optional>
namespace irr
{
@ -38,13 +37,13 @@ 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),
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)
@ -55,6 +54,7 @@ public:
updateAbsolutePosition();
}
//! Destructor
virtual ~ISceneNode()
{
@ -62,9 +62,10 @@ public:
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
precalculate the geometry which should be renderered, 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
@ -78,13 +79,15 @@ public:
*/
virtual void OnRegisterSceneNode()
{
if (IsVisible) {
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
@ -93,7 +96,8 @@ public:
\param timeMs Current time in milliseconds. */
virtual void OnAnimate(u32 timeMs)
{
if (IsVisible) {
if (IsVisible)
{
// update absolute position
updateAbsolutePosition();
@ -105,23 +109,35 @@ public:
}
}
//! 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
virtual const c8* getName() const
{
return Name;
return Name.c_str();
}
//! Sets the name of the node.
/** \param name New name of the scene node. */
virtual void setName(const std::optional<std::string> &name)
virtual void setName(const c8* name)
{
Name = name;
}
//! Sets the name of the node.
/** \param name New name of the scene node. */
virtual void setName(const core::stringc& 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
@ -132,6 +148,7 @@ public:
\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.
@ -168,6 +185,7 @@ public:
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
@ -179,7 +197,8 @@ public:
mat.setRotationDegrees(RelativeRotation);
mat.setTranslation(RelativeTranslation);
if (RelativeScale != core::vector3df(1.f, 1.f, 1.f)) {
if (RelativeScale != core::vector3df(1.f,1.f,1.f))
{
core::matrix4 smat;
smat.setScale(RelativeScale);
mat *= smat;
@ -188,6 +207,7 @@ public:
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
@ -222,6 +242,7 @@ public:
IsVisible = isVisible;
}
//! Get the id of the scene node.
/** This id can be used to identify the node.
\return The id. */
@ -230,6 +251,7 @@ public:
return ID;
}
//! Sets the id of the scene node.
/** This id can be used to identify the node.
\param id The new id. */
@ -238,59 +260,66 @@ public:
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)) {
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);
Children.push_back(child);
child->Parent = this;
}
}
//! Removes a child from this scene node.
/**
/** If found in the children list, the child pointer is also
dropped and might be deleted if no other grab exists.
\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. */
e.g. because it couldn't be found in the children list. */
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();
ISceneNodeList::iterator it = Children.begin();
for (; it != Children.end(); ++it)
if ((*it) == child)
{
(*it)->Parent = 0;
(*it)->drop();
Children.erase(it);
return true;
}
return false;
}
//! 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();
ISceneNodeList::iterator it = Children.begin();
for (; it != Children.end(); ++it)
{
(*it)->Parent = 0;
(*it)->drop();
}
Children.clear();
}
//! Removes this scene node from the scene
/** If no other grab exists for this node, it will be deleted.
*/
@ -300,6 +329,7 @@ public:
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
@ -313,6 +343,7 @@ public:
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
@ -320,17 +351,42 @@ public:
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)
//! Sets all material flags at once to a new value.
/** Useful, for example, if you want the whole mesh to be
affected by light.
\param flag Which flag of all materials to be set.
\param newvalue New value of that flag. */
void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue)
{
for (u32 i = 0; i < getMaterialCount(); i++) {
fn(getMaterial(i));
for (u32 i=0; i<getMaterialCount(); ++i)
getMaterial(i).setFlag(flag, newvalue);
}
//! Sets the texture of the specified layer in all materials of this scene node to the new texture.
/** \param textureLayer Layer of texture to be set. Must be a
value smaller than MATERIAL_MAX_TEXTURES.
\param texture New texture to be used. */
void setMaterialTexture(u32 textureLayer, video::ITexture* texture)
{
if (textureLayer >= video::MATERIAL_MAX_TEXTURES)
return;
for (u32 i=0; i<getMaterialCount(); ++i)
getMaterial(i).setTexture(textureLayer, texture);
}
//! Sets the material type of all materials in this scene node to a new material type.
/** \param newType New type of material to be set. */
void setMaterialType(video::E_MATERIAL_TYPE newType)
{
for (u32 i=0; i<getMaterialCount(); ++i)
getMaterial(i).MaterialType = newType;
}
//! 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
@ -341,6 +397,7 @@ public:
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)
@ -348,6 +405,7 @@ public:
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
@ -358,6 +416,7 @@ public:
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. */
@ -366,6 +425,7 @@ public:
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.
@ -375,6 +435,7 @@ public:
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. */
@ -383,6 +444,7 @@ public:
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.
@ -397,6 +459,7 @@ public:
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
@ -408,6 +471,7 @@ public:
AutomaticCullingState = state;
}
//! Gets the automatic culling state.
/** \return The automatic culling state. */
u32 getAutomaticCulling() const
@ -415,6 +479,7 @@ public:
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.
@ -432,6 +497,7 @@ public:
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. */
@ -440,6 +506,7 @@ public:
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.
@ -449,6 +516,7 @@ public:
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
@ -456,6 +524,7 @@ public:
return Children;
}
//! Changes the parent of the scene node.
/** \param newParent The new parent to be used. */
virtual void setParent(ISceneNode* newParent)
@ -463,24 +532,30 @@ public:
grab();
remove();
if (newParent)
newParent->addChild(this);
Parent = newParent;
if (Parent)
Parent->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) {
if (Parent)
{
AbsoluteTransformation =
Parent->getAbsoluteTransformation() * getRelativeTransformation();
} else
}
else
AbsoluteTransformation = getRelativeTransformation();
}
//! Returns the parent of this scene node
/** \return A pointer to the parent. */
scene::ISceneNode* getParent() const
@ -488,6 +563,7 @@ public:
return Parent;
}
//! Returns type of the scene node
/** \return The type of this node. */
virtual ESCENE_NODE_TYPE getType() const
@ -509,6 +585,7 @@ public:
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
@ -551,7 +628,7 @@ protected:
}
//! Name of the scene node.
std::optional<std::string> Name;
core::stringc Name;
//! Absolute transformation of the node.
core::matrix4 AbsoluteTransformation;
@ -565,15 +642,12 @@ protected:
//! 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;
//! List of all children of this node
std::list<ISceneNode*> Children;
//! Pointer to the scene manager
ISceneManager* SceneManager;
@ -593,5 +667,9 @@ protected:
bool IsDebugObject;
};
} // end namespace scene
} // end namespace irr
#endif

8
include/IShaderConstantSetCallBack.h
View file

@ -2,7 +2,8 @@
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#pragma once
#ifndef __I_SHADER_CONSTANT_SET_CALLBACT_H_INCLUDED__
#define __I_SHADER_CONSTANT_SET_CALLBACT_H_INCLUDED__
#include "IReferenceCounted.h"
@ -20,6 +21,7 @@ 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
@ -75,5 +77,9 @@ public:
virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData) = 0;
};
} // end namespace video
} // end namespace irr
#endif

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