77 Commits

Author SHA1 Message Date
99be15f40b Bump revision 2023-10-27 17:48:29 +02:00
6fccc79270 Convert built-in font to PNG 2023-10-25 16:54:43 +02:00
7cade6f27f cleanup: remove _IRR_COMPILE_ANDROID_ASSET_READER_ build flag
it's enabled inconditionally on android

also remove some _IRR_COMPILE_WITH_ANDROID_DEVICE_ which are useless because cmake is already properly configured
2023-10-22 12:19:14 +02:00
ae63f1bf02 build: drop _IRR_COMPILE_WITH_SKINNED_MESH_SUPPORT_
it's enabled inconditionally
2023-10-22 12:19:14 +02:00
dd14486d3f cleanup: replace remaining #ifndef #define with #pragma once 2023-10-22 12:19:14 +02:00
4a7d3de89a Merging r6555 through r6560 from branch releases/1.8 to trunk
- Fixing buffer overflow in tga loader

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6561 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-21 17:27:11 +02:00
631c0fa77b Add warning about rotateXZBy using right handed rotation
Rest of Irrlicht is using left-handed rotatations.
But 2d vector rotations all uses ccw which is kinda the same direction as this one if you consider those as rotations around Y, so I guess that was maybe the reason back then.

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6536 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:54:48 +02:00
9813b460e1 Fix number overflows in TGA loader causing crashes
Image size calculation could overflow s32 in one place (but not others where it was done correct), which first lead to wrong amount of memory getting allocated for image data and later crash in the CColorConverter.
Thanks @sfan5 for his fuzzing tests @https://github.com/minetest/irrlicht/issues/236
and @erlehmann for passing them on: https://irrlicht.sourceforge.io/forum/viewtopic.php?t=52925
Also updating changes.txt with TGA loader changes from this and previous commits.

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6535 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:54:39 +02:00
565f14677c Fix crash caused by memory overwriting in TGA loader caused by bad RLE data
From sfan5's fuzzing test reported in Minetest here: https://github.com/minetest/irrlicht/issues/236
Was missing test if it writes beyond allocated memory which can be triggered by TGA's which lie in their RLE data.

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6534 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:54:24 +02:00
f53af0f2cf TGA images with palettes in 24 or 32 bit now create 32 bit images
Was creating 16-bit images for those before.
Could also support 24-bit images, but either we need another convert function or another palette for that (the 16 and 32 bit both work with 32 bit palettes, the 24 bit conversion function only with 24 bit palettes)

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6533 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:54:21 +02:00
05ebc43222 Fix TGA's with bad palette colors reading from behind palette memory
TGA's can claim to use less palette colors than they later do.
We only support 8-bit palettes, so to make this safer lets just always allocate at least 256 bytes.
Thanks @erlehmann for report and testcase: https://irrlicht.sourceforge.io/forum/viewtopic.php?p=307191
Based on Minetest bug report: https://github.com/minetest/irrlicht/issues/236

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6532 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:54:16 +02:00
c01de80583 Merging r6511 through r6520 from branch releases/1.8 to trunk
Note: Due to OSX always failing merge OSX it's rather applying a second patch
from Ryan Schmidt from bugreport #462 to trunk
(Not sure why svn merging always fails for OSX. Probably related to MacOSX files getting moved in the past. Was that done without svn move commands? I guess that can't be fixed anymore now)

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6521 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:49:54 +02:00
fbdc4ee8d5 Optimization in quaternion::rotationFromTo from Robert Eisele
Turns out we can avoid a square root and a division.
Patch comes even with proof: https://raw.org/proof/quaternion-from-two-vectors
(I also tested it a while and indeed got same results)

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6511 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:47:43 +02:00
2c086e5fdc Improve documentation
What Irrlicht calls ShaderConstants is called uniforms by everyone else. So let's mention this at least.
Also reworked setVertexShaderConstant interface had an example for the old interface in the header.

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6497 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:45:50 +02:00
627a3a5172 Spelling fixes
git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6475 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:39:42 +02:00
01e05f3c94 Fix recently broken scroll behaviour of listbox with moveOverSelect
This also fixes the combobox which users the listbox like that.
This got broken in [r6454] which had fixed the events send out by the listbox
Note: Still a bit strange behaviour when leaving the combobox at the bottom, but that was already that way in Irrlicht 1.8, so I've got to investigate that on it's own.

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6463 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:38:24 +02:00
b673a4b2bb Tiny spelling fixes
git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6462 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:38:06 +02:00
5e01152f56 Avoid warning in VS 2022
git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6460 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:37:30 +02:00
c2dd664fc6 CIrrDeviceWin32::yield() now uses Sleep(0) instead of Sleep(1).
We had changed that once before in the other direction in svn r421
Reason back then was "Sleep(0) doesn't allow any lower priority threads to execute"
But Microsoft changed the behaviour of Sleep(0) after Windows XP so that's no longer true.
And the costs of it is pretty high - due to this using a timer with a 15ms resolutions it meant not just giving up the thread but it also always waited for 15ms on Windows.
I also replaced a few sleep calls in examples for that reason with yield() calls.

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6459 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:37:26 +02:00
774d3d6d2b Spelling fixes
git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6458 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:36:47 +02:00
e1f41edd29 Spelling fixes
git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6456 dfc29bdd-3216-0410-991c-e03cc46cb475
2023-10-15 13:36:22 +02:00
c766c3a023 Fix character encoding conversion issues 2023-10-15 12:59:40 +02:00
93eebed8c9 Unify documentation between IOSOperator and COSOperator 2023-10-15 12:59:40 +02:00
645b51a34d OpenGL3: Use std::vector in VertexType instead of clever lifetime games 2023-10-13 11:36:52 +02:00
bcc53e1e1a OpenGL3: Make sure mt_opengl is only included after GLAPI is defined 2023-10-13 11:36:52 +02:00
d4735ebc76 OpenGL3: Replace direct calls into libGL with mt_opengl 2023-10-13 11:36:52 +02:00
063079b372 OpenGL3: Make VertexType reference and not store the attribute list 2023-10-13 11:36:52 +02:00
3b198bdfda OpenGL3: Fix noexcept mismatch 2023-10-13 11:36:52 +02:00
5b2f1927d0 Revert #225 (d98dc90b38)
Fixes that Windows+SDL builds use the Windows Irrlicht device instead of the SDL Irrlicht device.
2023-10-04 23:29:59 +02:00
9954667c45 Cleanup line endings (#245)
The exact commands to make this commit were:

git reset --hard origin/master
find -type f |  # list all regular files
  grep -E '\.(h|cpp|fsh|vsh|mm)|LICENSE$' |  # filter for text files
  xargs -n 1 -P $(nproc) sed -i 's:\s*$::'  # for each file, trim trailing whitespace including the CR
git commit -a
2023-10-03 20:37:00 +02:00
ea1b58387e ComboBox API additions for minetest#13814
- Allow reliably detecting when the user opens a combobox.
- Allow preventing comboboxes from opening.
- Allow sending a combobox change event.
2023-09-30 16:46:30 +02:00
d767d27ca8 CXMeshFileLoader: revise error checking
Even when an error was encountered ::load() would still attempt
to assemble the mesh, this was a pretty big problem.
2023-09-29 13:49:03 +02:00
6f4f7c4d75 CXMeshFileLoader: fix buffer overreads with text format 2023-09-29 13:49:03 +02:00
103ab16679 CB3DMeshFileLoader: fix string read primitive 2023-09-29 13:49:03 +02:00
64688f4490 CB3DMeshFileLoader: add some bounds checks 2023-09-29 13:49:03 +02:00
827710f74a COBJMeshFileLoader: properly check indices 2023-09-29 13:49:03 +02:00
80e160935d COBJMeshFileLoader: fix buffer overruns 2023-09-29 13:49:03 +02:00
4506d23dc3 CImageLoaderBMP: add bound checks to RLE decompression 2023-09-29 13:49:03 +02:00
028cb8dbed CImageLoaderBMP: check bitmap data against required size 2023-09-29 13:49:03 +02:00
a5c9945bb8 CImageLoaderBMP: fix palette overreads 2023-09-29 13:49:03 +02:00
cfb73d07d7 Remove more obsolete files 2023-09-26 17:42:00 +02:00
87f7cf3438 Drop unused resource script 2023-09-26 17:42:00 +02:00
ebe4fd0a59 Refer to the origins in README 2023-09-26 17:42:00 +02:00
fc7e3f2dff Move license to the root 2023-09-26 17:42:00 +02:00
b0a070d980 Drop Irrlicht icon 2023-09-26 17:42:00 +02:00
d9216362ec Drop obsolete docs 2023-09-26 17:42:00 +02:00
d8a21cb25f Drop unused CIndexBuffer 2023-09-20 20:43:33 +02:00
9c54d927b9 Drop unused CVertexBuffer 2023-09-20 20:43:33 +02:00
b89455f385 Build OpenGL3 by default 2023-09-17 21:07:07 +02:00
6a5fceb8fd Hide OpenGL3 behind SDL2 (it won’t build otherwise anyway) 2023-09-17 21:07:07 +02:00
0b9ee5884f Fix Android build after #231 2023-09-17 20:34:43 +02:00
679dfd3343 Fix CNullDriver::removeTexture() segfault
`Textures` is not an one-to-one mapping.
Minetest still crashes with this commit but that's because
it attempts to double-free a texture.
broken by 7298b46504
2023-09-13 15:16:57 +02:00
f9d7a632f5 CI: Add MinGW builds with SDL 2023-09-13 13:26:01 +02:00
dc43583a2c CI: Merge 32- and 64-bit MinGW builds 2023-09-13 13:26:01 +02:00
03fd4ff533 Remove unused IVideoDriver::getTextureByIndex and IVideoDriver::renameTexture
* getTextureByIndex is pretty useless (apart from iterating over all texture,
  which we don't do), as you can't get an id.
* renameTexture is broken anyway: The sort call does nothing because the array
  is still flagged as sorted.
2023-09-13 13:24:08 +02:00
b7292226b4 Remove the unnecessary sort in CNullDriver::addTexture 2023-09-13 13:24:08 +02:00
7298b46504 Use binary search in CNullDriver::removeTexture() 2023-09-13 12:33:50 +02:00
af20d9ff86 Remove deprecated function transformBox 2023-09-05 17:21:35 +02:00
00dd1f8ef3 Remove deprecated functionality of SMaterial 2023-09-05 17:21:35 +02:00
364cb37698 Remove deprecated methods from IVideoDriver 2023-09-05 17:21:35 +02:00
7ce9169d8d Remove deprecated method getOperatingSystemVersion 2023-09-05 17:21:35 +02:00
ebdb2e410b Remove deprecated member functions of IMeshCache 2023-09-05 17:21:35 +02:00
a28b8f9e91 Remove deprecated member functions
Removes deprecated member functions of IMaterialRendererServices.
2023-09-05 17:21:35 +02:00
6cd27d5dca Remove deprecated IImage member functions 2023-09-05 17:21:35 +02:00
04ab99f218 Removes deprecated function getNumber
Removes deprecated function getNumber as well as makes all
line terminators the proper CR LN combo.
2023-09-05 17:21:35 +02:00
d753c8b782 Remove deprecated functions related to FileSystem 2023-09-05 17:21:35 +02:00
6a3ed6428f Remove deprecated getBoneName method 2023-09-05 17:21:35 +02:00
3492fd0d2d Remove primitive types not supported in OpenGL 3+
I removed old primitive types that do not work with modern OpenGL.
2023-09-05 17:21:35 +02:00
c6b06533f3 Deduplicate KP_5 from KP_HOME 2023-09-01 15:54:55 +02:00
e609f5f263 Remove leftovers from D3D 2023-09-01 12:45:56 +02:00
ddecc0fae2 Inline a pointless function 2023-09-01 12:26:43 +02:00
dd3a34d674 Remove unused (I)Timer methods 2023-09-01 12:22:27 +02:00
0735220f86 Suppress a -Wunused-but-set-variable warning 2023-08-29 17:33:25 +02:00
0740d055ac Fix uninitialized memory error in operator- for ustring16 iterators 2023-08-29 17:33:25 +02:00
1d4672bd92 Remove the now unused SMaterialLayer::setFiltersMinetest method 2023-08-24 17:20:54 +02:00
ef3bab610d CIrrDeviceLinux: Fix type for NET_WM_PID XChangeProperty
This uses format=32 which in X11's API means a C type of long (with
restricted range when > 32 bits). pid_t is of unknown type, though on
Linux and FreeBSD it's a 32-bit type, so does not have the same size as
long on 64-bit architectures, and thus XChangeProperty reads outside its
bounds. Fix this by casting to and passing a long.
2023-08-15 20:42:12 +02:00
d98dc90b38 cleanup: only build some files on WIN32 and compile EGL only if needed 2023-08-01 20:53:25 +02:00
339 changed files with 98532 additions and 103817 deletions

View File

@ -137,49 +137,37 @@ jobs:
cd bin/Linux cd bin/Linux
LIBGL_ALWAYS_SOFTWARE=true xvfb-run ./AutomatedTest ogles2 LIBGL_ALWAYS_SOFTWARE=true xvfb-run ./AutomatedTest ogles2
win32: mingw:
name: "MinGW ${{matrix.config.variant}}${{matrix.config.extras}}"
runs-on: ubuntu-20.04 runs-on: ubuntu-20.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: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v3
- name: Install compiler - name: Install compiler
run: | run: |
sudo apt-get update && sudo apt-get install cmake -qyy sudo apt-get update && sudo apt-get install cmake -qyy
wget http://minetest.kitsunemimi.pw/mingw-w64-i686_11.2.0_ubuntu20.04.tar.xz -O mingw.tar.xz wget http://minetest.kitsunemimi.pw/mingw-w64-${{matrix.config.arch}}_11.2.0_ubuntu20.04.tar.xz -O mingw.tar.xz
sudo tar -xaf mingw.tar.xz -C /usr sudo tar -xaf mingw.tar.xz -C /usr
- name: Build - name: Build
run: | run: |
./scripts/ci-build-mingw.sh package ./scripts/ci-build-mingw.sh package
env: env:
CC: i686-w64-mingw32-gcc CC: ${{matrix.config.arch}}-w64-mingw32-gcc
CXX: i686-w64-mingw32-g++ CXX: ${{matrix.config.arch}}-w64-mingw32-g++
extras: ${{matrix.config.extras}}
- uses: actions/upload-artifact@v3 - uses: actions/upload-artifact@v3
with: with:
name: irrlicht-win32 name: irrlicht-${{matrix.config.variant}}${{matrix.config.extras}}
path: ./irrlicht-win32.zip path: ./irrlicht-${{matrix.config.variant}}${{matrix.config.extras}}.zip
win64:
runs-on: ubuntu-20.04
steps:
- uses: actions/checkout@v3
- 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@v3
with:
name: irrlicht-win64
path: ./irrlicht-win64.zip
macos: macos:
runs-on: macos-latest runs-on: macos-latest

View File

@ -7,7 +7,7 @@ else()
cmake_policy(VERSION 3.11) cmake_policy(VERSION 3.11)
endif() endif()
set(IRRLICHTMT_REVISION 12) set(IRRLICHTMT_REVISION 13)
project(Irrlicht project(Irrlicht
VERSION 1.9.0.${IRRLICHTMT_REVISION} VERSION 1.9.0.${IRRLICHTMT_REVISION}

View File

@ -1 +0,0 @@
doc/irrlicht-license.txt

26
LICENSE Normal file
View File

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

View File

@ -1,9 +1,8 @@
IrrlichtMt version 1.9 IrrlichtMt version 1.9
====================== ======================
The Irrlicht Engine is an open source realtime 3D engine written in C++. 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. It is intentionally not compatible to upstream and is planned to be eventually absorbed into Minetest.
Build Build

View File

@ -1,4 +0,0 @@
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.

View File

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

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.2 KiB

View File

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

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.2 KiB

View File

@ -1,16 +0,0 @@
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.

View File

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

View File

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

View File

@ -1,63 +0,0 @@
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.

File diff suppressed because it is too large Load Diff

View File

@ -168,22 +168,32 @@ static void test_methods()
static void test_conv() static void test_conv()
{ {
// assumes Unicode and UTF-8 locale // locale-independent
setlocale(LC_CTYPE, "");
stringw out; stringw out;
multibyteToWString(out, "†††"); utf8ToWString(out, "†††");
UASSERTEQ(out.size(), 3); UASSERTEQ(out.size(), 3);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
UASSERTEQ(static_cast<u16>(out[i]), 0x2020); UASSERTEQ(static_cast<u16>(out[i]), 0x2020);
stringc out2; stringc out2;
wStringToMultibyte(out2, L"†††"); wStringToUTF8(out2, L"†††");
UASSERTEQ(out2.size(), 9); UASSERTEQ(out2.size(), 9);
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
UASSERTEQ(static_cast<u8>(out2[3*i]), 0xe2); UASSERTEQ(static_cast<u8>(out2[3*i]), 0xe2);
UASSERTEQ(static_cast<u8>(out2[3*i+1]), 0x80); UASSERTEQ(static_cast<u8>(out2[3*i+1]), 0x80);
UASSERTEQ(static_cast<u8>(out2[3*i+2]), 0xa0); 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() void test_irr_string()

View File

@ -1,226 +0,0 @@
// 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;
u32 stride() const override {return sizeof(T);}
u32 size() const override {return Indices.size();}
void push_back(const u32 &element) override
{
// push const ref due to compiler problem with gcc 4.6, big endian
Indices.push_back((const T&)element);
}
u32 operator [](u32 index) const override
{
return (u32)(Indices[index]);
}
u32 getLast() override {return (u32)Indices.getLast();}
void setValue(u32 index, u32 value) override
{
Indices[index]=(T)value;
}
void set_used(u32 usedNow) override
{
Indices.set_used(usedNow);
}
void reallocate(u32 new_size) override
{
Indices.reallocate(new_size);
}
u32 allocated_size() const override
{
return Indices.allocated_size();
}
void* pointer() override {return Indices.pointer();}
video::E_INDEX_TYPE getType() const 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);
void setType(video::E_INDEX_TYPE IndexType) 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;
}
void* getData() override {return Indices->pointer();}
video::E_INDEX_TYPE getType() const override {return Indices->getType();}
u32 stride() const override {return Indices->stride();}
u32 size() const override
{
return Indices->size();
}
void push_back(const u32 &element) override
{
Indices->push_back(element);
}
u32 operator [](u32 index) const override
{
return (*Indices)[index];
}
u32 getLast() override
{
return Indices->getLast();
}
void setValue(u32 index, u32 value) override
{
Indices->setValue(index, value);
}
void set_used(u32 usedNow) override
{
Indices->set_used(usedNow);
}
void reallocate(u32 new_size) override
{
Indices->reallocate(new_size);
}
u32 allocated_size() const override
{
return Indices->allocated_size();
}
void* pointer() override
{
return Indices->pointer();
}
//! get the current hardware mapping hint
E_HARDWARE_MAPPING getHardwareMappingHint() const override
{
return MappingHint;
}
//! set the hardware mapping hint, for driver
void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) override
{
MappingHint=NewMappingHint;
}
//! flags the mesh as changed, reloads hardware buffers
void setDirty() override
{
++ChangedID;
}
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
u32 getChangedID() const override {return ChangedID;}
E_HARDWARE_MAPPING MappingHint;
u32 ChangedID;
};
} // end namespace scene
} // end namespace irr
#endif

View File

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

View File

@ -20,13 +20,6 @@ namespace video
render and display any graphics. */ render and display any graphics. */
EDT_NULL, EDT_NULL,
// obsolete constants to make some code happy
// TODO delete
EDT_SOFTWARE,
EDT_BURNINGSVIDEO,
DEPRECATED_EDT_DIRECT3D8_NO_LONGER_EXISTS,
EDT_DIRECT3D9,
//! OpenGL device, available on most platforms. //! OpenGL device, available on most platforms.
/** Performs hardware accelerated rendering of 3D and 2D /** Performs hardware accelerated rendering of 3D and 2D
primitives. */ primitives. */

View File

@ -36,20 +36,6 @@ namespace scene
//! Explicitly set all vertices for each triangle. //! Explicitly set all vertices for each triangle.
EPT_TRIANGLES, 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. //! The single vertices are expanded to quad billboards on the GPU.
EPT_POINT_SPRITES EPT_POINT_SPRITES
}; };

View File

@ -59,10 +59,6 @@ namespace scene
IBoneSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id=-1) : IBoneSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id=-1) :
ISceneNode(parent, mgr, id),positionHint(-1),scaleHint(-1),rotationHint(-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 //! Get the index of the bone
virtual u32 getBoneIndex() const = 0; virtual u32 getBoneIndex() const = 0;

View File

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

View File

@ -26,7 +26,7 @@ namespace gui
ECI_HELP, // Arrow and question mark ECI_HELP, // Arrow and question mark
ECI_IBEAM, // typical text-selection cursor ECI_IBEAM, // typical text-selection cursor
ECI_NO, // should not click icon ECI_NO, // should not click icon
ECI_WAIT, // hourclass ECI_WAIT, // hourglass
ECI_SIZEALL, // arrow in all directions ECI_SIZEALL, // arrow in all directions
ECI_SIZENESW, // resizes in direction north-east or south-west ECI_SIZENESW, // resizes in direction north-east or south-west
ECI_SIZENWSE, // resizes in direction north-west or south-east ECI_SIZENWSE, // resizes in direction north-west or south-east

View File

@ -263,6 +263,10 @@ namespace irr
//! A checkbox has changed its check state. //! A checkbox has changed its check state.
EGET_CHECKBOX_CHANGED, 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. //! 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. */ /** NOTE: You also get this event currently when the same item was clicked again after more than 500 ms. */
EGET_LISTBOX_CHANGED, EGET_LISTBOX_CHANGED,

View File

@ -210,58 +210,6 @@ public:
\return A pointer to the specified loader, 0 if the index is incorrect. */ \return A pointer to the specified loader, 0 if the index is incorrect. */
virtual IArchiveLoader* getArchiveLoader(u32 index) const = 0; 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. //! Get the current working directory.
/** \return Current working directory as a string. */ /** \return Current working directory as a string. */
virtual const path& getWorkingDirectory() =0; virtual const path& getWorkingDirectory() =0;

View File

@ -52,6 +52,10 @@ namespace gui
//! Sets the selected item. Set this to -1 if no item should be selected //! Sets the selected item. Set this to -1 if no item should be selected
virtual void setSelected(s32 idx) = 0; 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 //! Sets text justification of the text area
/** \param horizontal: EGUIA_UPPERLEFT for left justified (default), /** \param horizontal: EGUIA_UPPERLEFT for left justified (default),
EGUIA_LOWERRIGHT for right justified, or EGUIA_CENTER for centered text. EGUIA_LOWERRIGHT for right justified, or EGUIA_CENTER for centered text.

View File

@ -129,15 +129,6 @@ namespace gui
IGUITab(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle) IGUITab(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
: IGUIElement(EGUIET_TAB, environment, parent, id, 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 //! sets if the tab should draw its background
virtual void setDrawBackground(bool draw=true) = 0; virtual void setDrawBackground(bool draw=true) = 0;

View File

@ -183,24 +183,6 @@ public:
return Data; 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 //! 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. /** 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. */ Doesn't care if the image actually has mipmaps, just which size would be needed. */
@ -367,19 +349,6 @@ public:
//! fills the surface with given color //! fills the surface with given color
virtual void fill(const SColor &color) =0; 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 //! get the amount of Bits per Pixel of the given color format
static u32 getBitsPerPixelFromFormat(const ECOLOR_FORMAT format) static u32 getBitsPerPixelFromFormat(const ECOLOR_FORMAT format)
{ {

View File

@ -19,7 +19,7 @@ enum ELOG_LEVEL
//! Used for printing information helpful in debugging //! Used for printing information helpful in debugging
ELL_DEBUG, ELL_DEBUG,
//! Useful information to print. For example hardware infos or something started/stopped. //! Useful information to print. For example hardware info or something started/stopped.
ELL_INFORMATION, ELL_INFORMATION,
//! Warnings that something isn't as expected and can cause oddities //! Warnings that something isn't as expected and can cause oddities

View File

@ -38,30 +38,11 @@ public:
const SMaterial& lastMaterial, const SMaterial& lastMaterial,
bool resetAllRenderstates) = 0; bool resetAllRenderstates) = 0;
//! Return an index constant for the vertex shader based on a name. //! Return an index constant for the vertex shader based on a uniform variable name.
virtual s32 getVertexShaderConstantID(const c8* name) = 0; virtual s32 getVertexShaderConstantID(const c8* name) = 0;
//! Sets a constant for the vertex shader based on a name. //! Sets a value for a vertex shader uniform variable.
/** This can be used if you used a high level shader language like GLSL /** \param index Index of the variable (as received from getVertexShaderConstantID)
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 floats Pointer to array of floats
\param count Amount of floats in array. \param count Amount of floats in array.
\return True if successful. \return True if successful.
@ -85,14 +66,14 @@ public:
\param constantAmount: Amount of registers to be set. One register consists of 4 floats. */ \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; virtual void setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1) = 0;
//! Return an index constant for the pixel shader based on a name. //! Return an index constant for the pixel shader for the given uniform variable name
virtual s32 getPixelShaderConstantID(const c8* name) = 0; virtual s32 getPixelShaderConstantID(const c8* name) = 0;
//! Sets a constant for the pixel shader based on a name. //! Sets a value for the given pixel shader uniform variable
/** This can be used if you used a high level shader language like GLSL /** This can be used if you used a high level shader language like GLSL
or HLSL to create a shader. See setVertexShaderConstant() for an or HLSL to create a shader. See setVertexShaderConstant() for an
example on how to use this. example on how to use this.
\param index Index of the variable \param index Index of the variable (as received from getPixelShaderConstantID)
\param floats Pointer to array of floats \param floats Pointer to array of floats
\param count Amount of floats in array. \param count Amount of floats in array.
\return True if successful. */ \return True if successful. */
@ -115,30 +96,6 @@ public:
\param constantAmount Amount of registers to be set. One register consists of 4 floats. */ \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; 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 //! Get pointer to the IVideoDriver interface
/** \return Pointer to the IVideoDriver interface */ /** \return Pointer to the IVideoDriver interface */
virtual IVideoDriver* getVideoDriver() = 0; virtual IVideoDriver* getVideoDriver() = 0;

View File

@ -172,9 +172,6 @@ namespace scene
case scene::EPT_TRIANGLE_STRIP: return (indexCount-2); case scene::EPT_TRIANGLE_STRIP: return (indexCount-2);
case scene::EPT_TRIANGLE_FAN: return (indexCount-2); case scene::EPT_TRIANGLE_FAN: return (indexCount-2);
case scene::EPT_TRIANGLES: return indexCount/3; 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; case scene::EPT_POINT_SPRITES: return indexCount;
} }
return 0; return 0;

View File

@ -78,46 +78,6 @@ namespace scene
number. */ number. */
virtual IAnimatedMesh* getMeshByIndex(u32 index) = 0; 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. //! Returns a mesh based on its name.
/** \param name Name of the mesh. Usually a filename. /** \param name Name of the mesh. Usually a filename.
\return Pointer to the mesh or 0 if there is none with this number. */ \return Pointer to the mesh or 0 if there is none with this number. */

View File

@ -2,9 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_I_MESH_WRITER_H_INCLUDED__ #pragma once
#define __IRR_I_MESH_WRITER_H_INCLUDED__
#include "IReferenceCounted.h" #include "IReferenceCounted.h"
#include "EMeshWriterEnums.h" #include "EMeshWriterEnums.h"
@ -54,5 +52,4 @@ namespace scene
} // end namespace } // end namespace
} // end namespace } // end namespace
#endif

View File

@ -11,20 +11,13 @@
namespace irr namespace irr
{ {
//! The Operating system operator provides operation system specific methods and information. //! The OSOperator provides OS-specific methods and information.
class IOSOperator : public virtual IReferenceCounted class IOSOperator : public virtual IReferenceCounted
{ {
public: public:
//! Get the current operation system version as string. //! Get the current OS version as string.
virtual const core::stringc& getOperatingSystemVersion() const = 0; 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 //! Copies text to the clipboard
//! \param text: text in utf-8 //! \param text: text in utf-8
virtual void copyToClipboard(const c8* text) const = 0; virtual void copyToClipboard(const c8* text) const = 0;

View File

@ -130,7 +130,7 @@ namespace scene
{ {
public: public:
//! Get pointer to an animateable mesh. Loads the file if not loaded already. //! Get pointer to an animatable mesh. Loads the file if not loaded already.
/** /**
* If you want to remove a loaded mesh from the cache again, use removeMesh(). * If you want to remove a loaded mesh from the cache again, use removeMesh().
* Currently there are the following mesh formats supported: * Currently there are the following mesh formats supported:
@ -509,7 +509,7 @@ namespace scene
//! Clear all nodes which are currently registered for rendering //! Clear all nodes which are currently registered for rendering
/** Usually you don't have to care about this as drawAll will clear nodes /** Usually you don't have to care about this as drawAll will clear nodes
after rendering them. But sometimes you might have to manully reset this. after rendering them. But sometimes you might have to manually reset this.
For example when you deleted nodes between registering and rendering. */ For example when you deleted nodes between registering and rendering. */
virtual void clearAllRegisteredNodesForRendering() = 0; virtual void clearAllRegisteredNodesForRendering() = 0;

View File

@ -65,7 +65,7 @@ namespace scene
//! This method is called just before the rendering process of the whole scene. //! This method is called just before the rendering process of the whole scene.
/** Nodes may register themselves in the render pipeline during this call, /** Nodes may register themselves in the render pipeline during this call,
precalculate the geometry which should be renderered, and prevent their precalculate the geometry which should be rendered, and prevent their
children from being able to register themselves if they are clipped by simply children from being able to register themselves if they are clipped by simply
not calling their OnRegisterSceneNode method. not calling their OnRegisterSceneNode method.
If you are implementing your own scene node, you should overwrite this method If you are implementing your own scene node, you should overwrite this method

View File

@ -97,14 +97,6 @@ enum E_TEXTURE_CREATION_FLAG
*/ */
ETCF_AUTO_GENERATE_MIP_MAPS = 0x00000100, ETCF_AUTO_GENERATE_MIP_MAPS = 0x00000100,
//! Enable support for vertex shader texture sampling on some drivers
/** Default is false.
This adds a small costs to all texture switches.
Currently only affects D3D9.
On OpenGL vertex shaders use the same texture unit as pixel shaders, so support there only depends on GL version and not on this flag
*/
ETCF_SUPPORT_VERTEXT_TEXTURE = 0x00000200,
/** This flag is never used, it only forces the compiler to compile /** This flag is never used, it only forces the compiler to compile
these enumeration values to 32 bit. */ these enumeration values to 32 bit. */
ETCF_FORCE_32_BIT_DO_NOT_USE = 0x7fffffff ETCF_FORCE_32_BIT_DO_NOT_USE = 0x7fffffff

View File

@ -21,41 +21,6 @@ public:
*/ */
virtual u32 getRealTime() const = 0; virtual u32 getRealTime() const = 0;
enum EWeekday
{
EWD_SUNDAY=0,
EWD_MONDAY,
EWD_TUESDAY,
EWD_WEDNESDAY,
EWD_THURSDAY,
EWD_FRIDAY,
EWD_SATURDAY
};
struct RealTimeDate
{
// Hour of the day, from 0 to 23
u32 Hour;
// Minute of the hour, from 0 to 59
u32 Minute;
// Second of the minute, due to extra seconds from 0 to 61
u32 Second;
// Year of the Gregorian calender
s32 Year;
// Month of the year, from 1 to 12
u32 Month;
// Day of the month, from 1 to 31
u32 Day;
// Weekday for the current day
EWeekday Weekday;
// Day of the year, from 1 to 366
u32 Yearday;
// Whether daylight saving is on
bool IsDST;
};
virtual RealTimeDate getRealTimeAndDate() const = 0;
//! Returns current virtual time in milliseconds. //! Returns current virtual time in milliseconds.
/** This value starts with 0 and can be manipulated using setTime(), /** This value starts with 0 and can be manipulated using setTime(),
stopTimer(), startTimer(), etc. This value depends on the set speed of stopTimer(), startTimer(), etc. This value depends on the set speed of

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_I_VIDEO_DRIVER_H_INCLUDED__ #pragma once
#define __IRR_I_VIDEO_DRIVER_H_INCLUDED__
#include "rect.h" #include "rect.h"
#include "SColor.h" #include "SColor.h"
@ -265,24 +264,10 @@ namespace video
IReferenceCounted::drop() for more information. */ IReferenceCounted::drop() for more information. */
virtual ITexture* getTexture(io::IReadFile* file) =0; virtual ITexture* getTexture(io::IReadFile* file) =0;
//! Returns a texture by index
/** \param index: Index of the texture, must be smaller than
getTextureCount() Please note that this index might change when
adding or removing textures
\return Pointer to the texture, or 0 if the texture was not
set or index is out of bounds. This pointer should not be
dropped. See IReferenceCounted::drop() for more information. */
virtual ITexture* getTextureByIndex(u32 index) =0;
//! Returns amount of textures currently loaded //! Returns amount of textures currently loaded
/** \return Amount of textures currently loaded */ /** \return Amount of textures currently loaded */
virtual u32 getTextureCount() const = 0; virtual u32 getTextureCount() const = 0;
//! Renames a texture
/** \param texture Pointer to the texture to rename.
\param newName New name for the texture. This should be a unique name. */
virtual void renameTexture(ITexture* texture, const io::path& newName) = 0;
//! Creates an empty texture of specified size. //! Creates an empty texture of specified size.
/** \param size: Size of the texture. /** \param size: Size of the texture.
\param name A name for the texture. Later calls to \param name A name for the texture. Later calls to
@ -297,24 +282,6 @@ namespace video
virtual ITexture* addTexture(const core::dimension2d<u32>& size, virtual ITexture* addTexture(const core::dimension2d<u32>& size,
const io::path& name, ECOLOR_FORMAT format = ECF_A8R8G8B8) = 0; const io::path& name, ECOLOR_FORMAT format = ECF_A8R8G8B8) = 0;
//! Creates a texture from an IImage.
/** \param name A name for the texture. Later calls of
getTexture() with this name will return this texture.
The name can _not_ be empty.
\param image Image the texture is created from.
\param mipmapData Optional pointer to a mipmaps data.
If this parameter is not given, the mipmaps are derived from image.
\return Pointer to the newly created texture. This pointer
should not be dropped. See IReferenceCounted::drop() for more
information. */
_IRR_DEPRECATED_ ITexture* addTexture(const io::path& name, IImage* image, void* mipmapData)
{
if (image)
image->setMipMapsData(mipmapData, false);
return addTexture(name, image);
}
//! Creates a texture from an IImage. //! Creates a texture from an IImage.
/** \param name A name for the texture. Later calls of /** \param name A name for the texture. Later calls of
getTexture() with this name will return this texture. getTexture() with this name will return this texture.
@ -366,8 +333,7 @@ namespace video
const io::path& name = "rt", const ECOLOR_FORMAT format = ECF_UNKNOWN) =0; const io::path& name = "rt", const ECOLOR_FORMAT format = ECF_UNKNOWN) =0;
//! Adds a new render target texture with 6 sides for a cubemap map to the texture cache. //! Adds a new render target texture with 6 sides for a cubemap map to the texture cache.
/** NOTE: Only supported on D3D9 so far. /** \param sideLen Length of one cubemap side.
\param sideLen Length of one cubemap side.
\param name A name for the texture. Later calls of getTexture() with this name will return this texture. \param name A name for the texture. Later calls of getTexture() with this name will return this texture.
The name can _not_ be empty. The name can _not_ be empty.
\param format The color format of the render target. Floating point formats are supported. \param format The color format of the render target. Floating point formats are supported.
@ -459,15 +425,9 @@ namespace video
color values may not be exactly the same in the engine and for color values may not be exactly the same in the engine and for
example in picture edit programs. To avoid this problem, you example in picture edit programs. To avoid this problem, you
could use the makeColorKeyTexture method, which takes the could use the makeColorKeyTexture method, which takes the
position of a pixel instead a color value. position of a pixel instead a color value. */
\param zeroTexels (deprecated) If set to true, then any texels that match
the color key will have their color, as well as their alpha, set to zero
(i.e. black). This behavior matches the legacy (buggy) behavior prior
to release 1.5 and is provided for backwards compatibility only.
This parameter may be removed by Irrlicht 1.9. */
virtual void makeColorKeyTexture(video::ITexture* texture, virtual void makeColorKeyTexture(video::ITexture* texture,
video::SColor color, video::SColor color) const =0;
bool zeroTexels = false) const =0;
//! Sets a boolean alpha channel on the texture based on the color at a position. //! Sets a boolean alpha channel on the texture based on the color at a position.
/** This makes the texture fully transparent at the texels where /** This makes the texture fully transparent at the texels where
@ -476,15 +436,9 @@ namespace video
\param texture Texture whose alpha channel is modified. \param texture Texture whose alpha channel is modified.
\param colorKeyPixelPos Position of a pixel with the color key \param colorKeyPixelPos Position of a pixel with the color key
color. Every texel with this color will become fully transparent as color. Every texel with this color will become fully transparent as
described above. described above. */
\param zeroTexels (deprecated) If set to true, then any texels that match
the color key will have their color, as well as their alpha, set to zero
(i.e. black). This behavior matches the legacy (buggy) behavior prior
to release 1.5 and is provided for backwards compatibility only.
This parameter may be removed by Irrlicht 1.9. */
virtual void makeColorKeyTexture(video::ITexture* texture, virtual void makeColorKeyTexture(video::ITexture* texture,
core::position2d<s32> colorKeyPixelPos, core::position2d<s32> colorKeyPixelPos) const =0;
bool zeroTexels = false) const =0;
//! Set a render target. //! Set a render target.
/** This will only work if the driver supports the /** This will only work if the driver supports the
@ -1032,27 +986,6 @@ namespace video
See IReferenceCounted::drop() for more information. */ See IReferenceCounted::drop() for more information. */
virtual IImage* createImage(ECOLOR_FORMAT format, const core::dimension2d<u32>& size) =0; virtual IImage* createImage(ECOLOR_FORMAT format, const core::dimension2d<u32>& size) =0;
//! Creates a software image by converting it to given format from another image.
/** \deprecated Create an empty image and use copyTo(). This method may be removed by Irrlicht 1.9.
\param format Desired color format of the image.
\param imageToCopy Image to copy to the new image.
\return The created image.
If you no longer need the image, you should call IImage::drop().
See IReferenceCounted::drop() for more information. */
_IRR_DEPRECATED_ virtual IImage* createImage(ECOLOR_FORMAT format, IImage *imageToCopy) =0;
//! Creates a software image from a part of another image.
/** \deprecated Create an empty image and use copyTo(). This method may be removed by Irrlicht 1.9.
\param imageToCopy Image to copy to the new image in part.
\param pos Position of rectangle to copy.
\param size Extents of rectangle to copy.
\return The created image.
If you no longer need the image, you should call IImage::drop().
See IReferenceCounted::drop() for more information. */
_IRR_DEPRECATED_ virtual IImage* createImage(IImage* imageToCopy,
const core::position2d<s32>& pos,
const core::dimension2d<u32>& size) =0;
//! Creates a software image from a part of a texture. //! Creates a software image from a part of a texture.
/** /**
\param texture Texture to copy to the new image in part. \param texture Texture to copy to the new image in part.
@ -1113,7 +1046,7 @@ namespace video
E_MATERIAL_TYPE enum or a value which was returned by E_MATERIAL_TYPE enum or a value which was returned by
addMaterialRenderer(). addMaterialRenderer().
\return String with the name of the renderer, or 0 if not \return String with the name of the renderer, or 0 if not
exisiting */ existing */
virtual const c8* getMaterialRendererName(u32 idx) const =0; virtual const c8* getMaterialRendererName(u32 idx) const =0;
//! Sets the name of a material renderer. //! Sets the name of a material renderer.
@ -1156,23 +1089,6 @@ namespace video
//! Clear the color, depth and/or stencil buffers. //! Clear the color, depth and/or stencil buffers.
virtual void clearBuffers(u16 flag, SColor color = SColor(255,0,0,0), f32 depth = 1.f, u8 stencil = 0) = 0; virtual void clearBuffers(u16 flag, SColor color = SColor(255,0,0,0), f32 depth = 1.f, u8 stencil = 0) = 0;
//! Clear the color, depth and/or stencil buffers.
_IRR_DEPRECATED_ void clearBuffers(bool backBuffer, bool depthBuffer, bool stencilBuffer, SColor color)
{
u16 flag = 0;
if (backBuffer)
flag |= ECBF_COLOR;
if (depthBuffer)
flag |= ECBF_DEPTH;
if (stencilBuffer)
flag |= ECBF_STENCIL;
clearBuffers(flag, color);
}
//! Clears the ZBuffer. //! Clears the ZBuffer.
/** Note that you usually need not to call this method, as it /** Note that you usually need not to call this method, as it
is automatically done in IVideoDriver::beginScene() or is automatically done in IVideoDriver::beginScene() or
@ -1294,4 +1210,3 @@ namespace video
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,12 +2,11 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_COMPILE_CONFIG_H_INCLUDED__ #pragma once
#define __IRR_COMPILE_CONFIG_H_INCLUDED__
//! Identifies the IrrlichtMt fork customized for the Minetest engine //! Identifies the IrrlichtMt fork customized for the Minetest engine
#define IRRLICHT_VERSION_MT_REVISION 12 #define IRRLICHT_VERSION_MT_REVISION 13
#define IRRLICHT_VERSION_MT "mt12" #define IRRLICHT_VERSION_MT "mt13"
//! Irrlicht SDK Version //! Irrlicht SDK Version
#define IRRLICHT_VERSION_MAJOR 1 #define IRRLICHT_VERSION_MAJOR 1
@ -29,5 +28,3 @@
#ifndef IRRLICHT_API #ifndef IRRLICHT_API
#define IRRLICHT_API #define IRRLICHT_API
#endif #endif
#endif // __IRR_COMPILE_CONFIG_H_INCLUDED__

View File

@ -76,13 +76,17 @@ namespace irr
virtual bool run() = 0; virtual bool run() = 0;
//! Cause the device to temporarily pause execution and let other processes run. //! Cause the device to temporarily pause execution and let other processes run.
/** This should bring down processor usage without major /** This should bring down processor usage without major performance loss for Irrlicht.
performance loss for Irrlicht */ But this is system dependent, so there's a chance your thread won't get control back quickly.
*/
virtual void yield() = 0; virtual void yield() = 0;
//! Pause execution and let other processes to run for a specified amount of time. //! Pause execution and let other processes to run for a specified amount of time.
/** It may not wait the full given time, as sleep may be interrupted /** It may not wait the full given time, as sleep may be interrupted and also may wait longer on some OS.
\param timeMs: Time to sleep for in milliseconds. \param timeMs: Time to sleep for in milliseconds. Note that the OS can round up this number.
On Windows you usually get at least 15ms sleep time minium for any value > 0.
So if you call this in your main loop you can't get more than 65 FPS anymore in your game.
On most Linux systems it's relatively exact, but also no guarantee.
\param pauseTimer: If true, pauses the device timer while sleeping \param pauseTimer: If true, pauses the device timer while sleeping
*/ */
virtual void sleep(u32 timeMs, bool pauseTimer=false) = 0; virtual void sleep(u32 timeMs, bool pauseTimer=false) = 0;

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_KEY_CODES_H_INCLUDED__ #pragma once
#define __IRR_KEY_CODES_H_INCLUDED__
namespace irr namespace irr
{ {
@ -90,7 +89,7 @@ namespace irr
KEY_KEY_X = 0x58, // X key KEY_KEY_X = 0x58, // X key
KEY_KEY_Y = 0x59, // Y key KEY_KEY_Y = 0x59, // Y key
KEY_KEY_Z = 0x5A, // Z key KEY_KEY_Z = 0x5A, // Z key
KEY_LWIN = 0x5B, // Left Windows key (Microsoft<EFBFBD> Natural<EFBFBD> keyboard) KEY_LWIN = 0x5B, // Left Windows key (Microsoft Natural keyboard)
KEY_RWIN = 0x5C, // Right Windows key (Natural keyboard) KEY_RWIN = 0x5C, // Right Windows key (Natural keyboard)
KEY_APPS = 0x5D, // Applications key (Natural keyboard) KEY_APPS = 0x5D, // Applications key (Natural keyboard)
KEY_SLEEP = 0x5F, // Computer Sleep key KEY_SLEEP = 0x5F, // Computer Sleep key
@ -185,5 +184,4 @@ namespace irr
} // end namespace irr } // end namespace irr
#endif

View File

@ -5,12 +5,6 @@
#ifndef __S_EXPOSED_VIDEO_DATA_H_INCLUDED__ #ifndef __S_EXPOSED_VIDEO_DATA_H_INCLUDED__
#define __S_EXPOSED_VIDEO_DATA_H_INCLUDED__ #define __S_EXPOSED_VIDEO_DATA_H_INCLUDED__
// forward declarations for internal pointers
struct IDirect3D9;
struct IDirect3DDevice9;
struct IDirect3D8;
struct IDirect3DDevice8;
namespace irr namespace irr
{ {
namespace video namespace video
@ -27,19 +21,6 @@ struct SExposedVideoData
SExposedVideoData() {OpenGLWin32.HDc=0; OpenGLWin32.HRc=0; OpenGLWin32.HWnd=0;} SExposedVideoData() {OpenGLWin32.HDc=0; OpenGLWin32.HRc=0; OpenGLWin32.HWnd=0;}
explicit SExposedVideoData(void* Window) {OpenGLWin32.HDc=0; OpenGLWin32.HRc=0; OpenGLWin32.HWnd=Window;} explicit SExposedVideoData(void* Window) {OpenGLWin32.HDc=0; OpenGLWin32.HRc=0; OpenGLWin32.HWnd=Window;}
struct SD3D9
{
//! Pointer to the IDirect3D9 interface
IDirect3D9* D3D9;
//! Pointer to the IDirect3DDevice9 interface
IDirect3DDevice9* D3DDev9;
//! Window handle.
/** Get with for example HWND h = reinterpret_cast<HWND>(exposedData.D3D9.HWnd) */
void* HWnd;
};
struct SOpenGLWin32 struct SOpenGLWin32
{ {
//! Private GDI Device Context. //! Private GDI Device Context.
@ -87,7 +68,6 @@ struct SExposedVideoData
union union
{ {
SD3D9 D3D9;
SOpenGLWin32 OpenGLWin32; SOpenGLWin32 OpenGLWin32;
SOpenGLLinux OpenGLLinux; SOpenGLLinux OpenGLLinux;
SOpenGLOSX OpenGLOSX; SOpenGLOSX OpenGLOSX;

View File

@ -40,7 +40,6 @@ namespace irr
Doublebuffer(true), Doublebuffer(true),
IgnoreInput(false), IgnoreInput(false),
Stereobuffer(false), Stereobuffer(false),
HighPrecisionFPU(false),
EventReceiver(0), EventReceiver(0),
WindowId(0), WindowId(0),
#ifdef _DEBUG #ifdef _DEBUG
@ -48,9 +47,6 @@ namespace irr
#else #else
LoggingLevel(ELL_INFORMATION), LoggingLevel(ELL_INFORMATION),
#endif #endif
DisplayAdapter(0),
DriverMultithreaded(false),
UsePerformanceTimer(true),
SDK_version_do_not_use(IRRLICHT_SDK_VERSION), SDK_version_do_not_use(IRRLICHT_SDK_VERSION),
PrivateData(0), PrivateData(0),
#ifdef IRR_MOBILE_PATHS #ifdef IRR_MOBILE_PATHS
@ -84,13 +80,9 @@ namespace irr
Doublebuffer = other.Doublebuffer; Doublebuffer = other.Doublebuffer;
IgnoreInput = other.IgnoreInput; IgnoreInput = other.IgnoreInput;
Stereobuffer = other.Stereobuffer; Stereobuffer = other.Stereobuffer;
HighPrecisionFPU = other.HighPrecisionFPU;
EventReceiver = other.EventReceiver; EventReceiver = other.EventReceiver;
WindowId = other.WindowId; WindowId = other.WindowId;
LoggingLevel = other.LoggingLevel; LoggingLevel = other.LoggingLevel;
DisplayAdapter = other.DisplayAdapter;
DriverMultithreaded = other.DriverMultithreaded;
UsePerformanceTimer = other.UsePerformanceTimer;
PrivateData = other.PrivateData; PrivateData = other.PrivateData;
OGLES2ShaderPath = other.OGLES2ShaderPath; OGLES2ShaderPath = other.OGLES2ShaderPath;
return *this; return *this;
@ -108,9 +100,6 @@ namespace irr
E_DEVICE_TYPE DeviceType; E_DEVICE_TYPE DeviceType;
//! Type of video driver used to render graphics. //! Type of video driver used to render graphics.
/** This can currently be video::EDT_NULL, video::EDT_SOFTWARE,
video::EDT_BURNINGSVIDEO, video::EDT_DIRECT3D9, and video::EDT_OPENGL.
Default: EDT_BURNINGSVIDEO. */
video::E_DRIVER_TYPE DriverType; video::E_DRIVER_TYPE DriverType;
//! Size of the window or the video mode in fullscreen mode. Default: 800x600 //! Size of the window or the video mode in fullscreen mode. Default: 800x600
@ -219,15 +208,6 @@ namespace irr
Default value: false */ Default value: false */
bool Stereobuffer; bool Stereobuffer;
//! Specifies if the device should use high precision FPU setting
/** This is only relevant for DirectX Devices, which switch to
low FPU precision by default for performance reasons. However,
this may lead to problems with the other computations of the
application. In this case setting this flag to true should help
- on the expense of performance loss, though.
Default value: false */
bool HighPrecisionFPU;
//! A user created event receiver. //! A user created event receiver.
IEventReceiver* EventReceiver; IEventReceiver* EventReceiver;
@ -292,23 +272,6 @@ namespace irr
*/ */
ELOG_LEVEL LoggingLevel; ELOG_LEVEL LoggingLevel;
//! Allows to select which graphic card is used for rendering when more than one card is in the system.
/** So far only supported on D3D */
u32 DisplayAdapter;
//! Create the driver multithreaded.
/** Default is false. Enabling this can slow down your application.
Note that this does _not_ make Irrlicht threadsafe, but only the underlying driver-API for the graphiccard.
So far only supported on D3D. */
bool DriverMultithreaded;
//! Enables use of high performance timers on Windows platform.
/** When performance timers are not used, standard GetTickCount()
is used instead which usually has worse resolution, but also less
problems with speed stepping and other techniques.
*/
bool UsePerformanceTimer;
//! Don't use or change this parameter. //! Don't use or change this parameter.
/** Always set it to IRRLICHT_SDK_VERSION, which is done by default. /** Always set it to IRRLICHT_SDK_VERSION, which is done by default.
This is needed for sdk version checks. */ This is needed for sdk version checks. */

View File

@ -228,19 +228,6 @@ namespace video
ECM_DIFFUSE_AND_AMBIENT ECM_DIFFUSE_AND_AMBIENT
}; };
//! DEPRECATED. Will be removed after Irrlicht 1.9.
/** Flags for the definition of the polygon offset feature. These flags define whether the offset should be into the screen, or towards the eye. */
enum E_POLYGON_OFFSET
{
//! Push pixel towards the far plane, away from the eye
/** This is typically used for rendering inner areas. */
EPO_BACK=0,
//! Pull pixels towards the camera.
/** This is typically used for polygons which should appear on top
of other elements, such as decals. */
EPO_FRONT=1
};
//! Names for polygon offset direction //! Names for polygon offset direction
const c8* const PolygonOffsetDirectionNames[] = const c8* const PolygonOffsetDirectionNames[] =
{ {
@ -289,17 +276,17 @@ namespace video
{ {
public: public:
//! Default constructor. Creates a solid, lit material with white colors //! Default constructor. Creates a solid, lit material with white colors
SMaterial() SMaterial() :
: MaterialType(EMT_SOLID), AmbientColor(255,255,255,255), DiffuseColor(255,255,255,255), MaterialType(EMT_SOLID), AmbientColor(255, 255, 255, 255),
EmissiveColor(0,0,0,0), SpecularColor(255,255,255,255), DiffuseColor(255, 255, 255, 255), EmissiveColor(0, 0, 0, 0),
Shininess(0.0f), MaterialTypeParam(0.0f), Thickness(1.0f), SpecularColor(255, 255, 255, 255), Shininess(0.0f),
ZBuffer(ECFN_LESSEQUAL), AntiAliasing(EAAM_SIMPLE), ColorMask(ECP_ALL), MaterialTypeParam(0.0f), Thickness(1.0f), ZBuffer(ECFN_LESSEQUAL),
ColorMaterial(ECM_DIFFUSE), BlendOperation(EBO_NONE), BlendFactor(0.0f), AntiAliasing(EAAM_SIMPLE), ColorMask(ECP_ALL), ColorMaterial(ECM_DIFFUSE),
PolygonOffsetFactor(0), PolygonOffsetDirection(EPO_FRONT), BlendOperation(EBO_NONE), BlendFactor(0.0f), PolygonOffsetDepthBias(0.f),
PolygonOffsetDepthBias(0.f), PolygonOffsetSlopeScale(0.f), PolygonOffsetSlopeScale(0.f), Wireframe(false), PointCloud(false),
Wireframe(false), PointCloud(false), GouraudShading(true), GouraudShading(true), Lighting(true), ZWriteEnable(EZW_AUTO),
Lighting(true), ZWriteEnable(EZW_AUTO), BackfaceCulling(true), FrontfaceCulling(false), BackfaceCulling(true), FrontfaceCulling(false), FogEnable(false),
FogEnable(false), NormalizeNormals(false), UseMipMaps(true) NormalizeNormals(false), UseMipMaps(true)
{ } { }
//! Texture layer array. //! Texture layer array.
@ -395,18 +382,6 @@ namespace video
(setting it to EBO_ADD is probably the most common one value). */ (setting it to EBO_ADD is probably the most common one value). */
f32 BlendFactor; f32 BlendFactor;
//! DEPRECATED. Will be removed after Irrlicht 1.9. Please use PolygonOffsetDepthBias instead.
/** Factor specifying how far the polygon offset should be made.
Specifying 0 disables the polygon offset. The direction is specified separately.
The factor can be from 0 to 7.
Note: This probably never worked on Direct3D9 (was coded for D3D8 which had different value ranges) */
u8 PolygonOffsetFactor:3;
//! DEPRECATED. Will be removed after Irrlicht 1.9.
/** Flag defining the direction the polygon offset is applied to.
Can be to front or to back, specified by values from E_POLYGON_OFFSET. */
E_POLYGON_OFFSET PolygonOffsetDirection:1;
//! A constant z-buffer offset for a polygon/line/point //! A constant z-buffer offset for a polygon/line/point
/** The range of the value is driver specific. /** The range of the value is driver specific.
On OpenGL you get units which are multiplied by the smallest value that is guaranteed to produce a resolvable offset. On OpenGL you get units which are multiplied by the smallest value that is guaranteed to produce a resolvable offset.
@ -546,8 +521,6 @@ namespace video
ColorMaterial != b.ColorMaterial || ColorMaterial != b.ColorMaterial ||
BlendOperation != b.BlendOperation || BlendOperation != b.BlendOperation ||
BlendFactor != b.BlendFactor || BlendFactor != b.BlendFactor ||
PolygonOffsetFactor != b.PolygonOffsetFactor ||
PolygonOffsetDirection != b.PolygonOffsetDirection ||
PolygonOffsetDepthBias != b.PolygonOffsetDepthBias || PolygonOffsetDepthBias != b.PolygonOffsetDepthBias ||
PolygonOffsetSlopeScale != b.PolygonOffsetSlopeScale || PolygonOffsetSlopeScale != b.PolygonOffsetSlopeScale ||
UseMipMaps != b.UseMipMaps UseMipMaps != b.UseMipMaps

View File

@ -232,16 +232,6 @@ namespace video
if the value is positive. */ if the value is positive. */
s8 LODBias; s8 LODBias;
//! Sets the MinFilter, MagFilter and AnisotropicFilter properties according
//! to the three relevant boolean values found in the Minetest settings.
/** The value of `trilinear` takes precedence over the value of `bilinear`. */
void setFiltersMinetest(bool bilinear, bool trilinear, bool anisotropic) {
MinFilter = trilinear ? ETMINF_LINEAR_MIPMAP_LINEAR :
(bilinear ? ETMINF_LINEAR_MIPMAP_NEAREST : ETMINF_NEAREST_MIPMAP_NEAREST);
MagFilter = (trilinear || bilinear) ? ETMAGF_LINEAR : ETMAGF_NEAREST;
AnisotropicFilter = anisotropic ? 0xFF : 0;
}
private: private:
friend class SMaterial; friend class SMaterial;

View File

@ -151,8 +151,6 @@ namespace video
case EMP_BLEND_OPERATION: material.BlendOperation = Material.BlendOperation; break; case EMP_BLEND_OPERATION: material.BlendOperation = Material.BlendOperation; break;
case EMP_BLEND_FACTOR: material.BlendFactor = Material.BlendFactor; break; case EMP_BLEND_FACTOR: material.BlendFactor = Material.BlendFactor; break;
case EMP_POLYGON_OFFSET: case EMP_POLYGON_OFFSET:
material.PolygonOffsetDirection = Material.PolygonOffsetDirection;
material.PolygonOffsetFactor = Material.PolygonOffsetFactor;
material.PolygonOffsetDepthBias = Material.PolygonOffsetDepthBias; material.PolygonOffsetDepthBias = Material.PolygonOffsetDepthBias;
material.PolygonOffsetSlopeScale = Material.PolygonOffsetSlopeScale; material.PolygonOffsetSlopeScale = Material.PolygonOffsetSlopeScale;
break; break;

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_AABBOX_3D_H_INCLUDED__ #pragma once
#define __IRR_AABBOX_3D_H_INCLUDED__
#include "irrMath.h" #include "irrMath.h"
#include "plane3d.h" #include "plane3d.h"
@ -364,6 +363,3 @@ class aabbox3d
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_CORE_UTIL_H_INCLUDED__ #pragma once
#define __IRR_CORE_UTIL_H_INCLUDED__
#include "irrString.h" #include "irrString.h"
#include "path.h" #include "path.h"
@ -202,4 +201,3 @@ inline bool isupper(s32 c) { return c >= 'A' && c <= 'Z'; }
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_DIMENSION2D_H_INCLUDED__ #pragma once
#define __IRR_DIMENSION2D_H_INCLUDED__
#include "irrTypes.h" #include "irrTypes.h"
#include "irrMath.h" // for irr::core::equals() #include "irrMath.h" // for irr::core::equals()
@ -220,5 +219,4 @@ namespace core
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,9 +2,7 @@
// This file is part of the "Irrlicht Engine" and the "irrXML" project. // This file is part of the "Irrlicht Engine" and the "irrXML" project.
// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h // For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
#ifndef __IRR_ARRAY_H_INCLUDED__ #pragma once
#define __IRR_ARRAY_H_INCLUDED__
#include <algorithm> #include <algorithm>
#include <iterator> #include <iterator>
#include <vector> #include <vector>
@ -438,5 +436,4 @@ private:
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_MATH_H_INCLUDED__ #pragma once
#define __IRR_MATH_H_INCLUDED__
#include "irrTypes.h" #include "irrTypes.h"
#include <math.h> #include <math.h>
@ -479,4 +478,3 @@ namespace core
using irr::core::IR; using irr::core::IR;
using irr::core::FR; using irr::core::FR;
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine" and the "irrXML" project. // This file is part of the "Irrlicht Engine" and the "irrXML" project.
// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h // For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
#ifndef __IRR_STRING_H_INCLUDED__ #pragma once
#define __IRR_STRING_H_INCLUDED__
#include "irrTypes.h" #include "irrTypes.h"
#include <string> #include <string>
@ -11,6 +10,8 @@
#include <cstdio> #include <cstdio>
#include <cstring> #include <cstring>
#include <cwchar> #include <cwchar>
#include <codecvt>
#include <locale>
namespace irr namespace irr
{ {
@ -35,8 +36,13 @@ outside the string class for explicit use.
// forward declarations // forward declarations
template <typename T> template <typename T>
class string; class string;
static size_t multibyteToWString(string<wchar_t>& destination, const char* source, u32 sourceSize);
static size_t wStringToMultibyte(string<c8>& destination, const wchar_t* source, u32 sourceSize); //! Typedef for character strings
typedef string<c8> stringc;
//! Typedef for wide character strings
typedef string<wchar_t> stringw;
//! Returns a character converted to lower case //! Returns a character converted to lower case
static inline u32 locale_lower ( u32 x ) static inline u32 locale_lower ( u32 x )
@ -859,8 +865,11 @@ public:
return ret.size()-oldSize; return ret.size()-oldSize;
} }
friend size_t multibyteToWString(string<wchar_t>& destination, const char* source, u32 sourceSize); // This function should not be used and is only kept for "CGUIFileOpenDialog::pathToStringW".
friend size_t wStringToMultibyte(string<c8>& destination, const wchar_t* source, u32 sourceSize); friend size_t multibyteToWString(stringw& destination, const stringc &source);
friend size_t utf8ToWString(stringw &destination, const char *source);
friend size_t wStringToUTF8(stringc &destination, const wchar_t *source);
private: private:
@ -913,38 +922,18 @@ private:
}; };
//! Typedef for character strings
typedef string<c8> stringc;
//! Typedef for wide character strings
typedef string<wchar_t> stringw;
//! Convert multibyte string to wide-character string //! Convert multibyte string to wide-character string
/** Wrapper around mbstowcs from standard library, but directly using Irrlicht string class. /** Wrapper around mbstowcs from standard library, but directly using Irrlicht string class.
What the function does exactly depends on the LC_CTYPE of the current c locale. What the function does exactly depends on the LC_CTYPE of the current c locale.
\param destination Wide-character string receiving the converted source \param destination Wide-character string receiving the converted source
\param source multibyte string \param source multibyte string
\return The number of wide characters written to destination, not including the eventual terminating null character or -1 when conversion failed */ \return The number of wide characters written to destination, not including the eventual terminating null character or -1 when conversion failed
static inline size_t multibyteToWString(string<wchar_t>& destination, const core::string<c8>& source)
{
return multibyteToWString(destination, source.c_str(), (u32)source.size());
}
//! Convert multibyte string to wide-character string This function should not be used and is only kept for "CGUIFileOpenDialog::pathToStringW". */
/** Wrapper around mbstowcs from standard library, but directly writing to Irrlicht string class. inline size_t multibyteToWString(stringw& destination, const core::stringc& source)
What the function does exactly depends on the LC_CTYPE of the current c locale.
\param destination Wide-character string receiving the converted source
\param source multibyte string
\return The number of wide characters written to destination, not including the eventual terminating null character or -1 when conversion failed. */
static inline size_t multibyteToWString(string<wchar_t>& destination, const char* source)
{ {
const u32 s = source ? (u32)strlen(source) : 0; u32 sourceSize = source.size();
return multibyteToWString(destination, source, s);
}
//! Internally used by the other multibyteToWString functions
static size_t multibyteToWString(string<wchar_t>& destination, const char* source, u32 sourceSize)
{
if ( sourceSize ) if ( sourceSize )
{ {
destination.str.resize(sourceSize+1); destination.str.resize(sourceSize+1);
@ -952,7 +941,7 @@ static size_t multibyteToWString(string<wchar_t>& destination, const char* sourc
#pragma warning(push) #pragma warning(push)
#pragma warning(disable: 4996) // 'mbstowcs': This function or variable may be unsafe. Consider using mbstowcs_s instead. #pragma warning(disable: 4996) // 'mbstowcs': This function or variable may be unsafe. Consider using mbstowcs_s instead.
#endif #endif
const size_t written = mbstowcs(&destination[0], source, (size_t)sourceSize); const size_t written = mbstowcs(&destination[0], source.c_str(), (size_t)sourceSize);
#if defined(_MSC_VER) #if defined(_MSC_VER)
#pragma warning(pop) #pragma warning(pop)
#endif #endif
@ -975,55 +964,33 @@ static size_t multibyteToWString(string<wchar_t>& destination, const char* sourc
} }
} }
//! Same as multibyteToWString, but the other way around
static inline size_t wStringToMultibyte(string<c8>& destination, const core::string<wchar_t>& source) inline size_t utf8ToWString(stringw &destination, const char *source)
{ {
return wStringToMultibyte(destination, source.c_str(), (u32)source.size()); std::wstring_convert<std::codecvt_utf8<wchar_t>> conv;
destination = conv.from_bytes(source);
return destination.size();
} }
//! Same as multibyteToWString, but the other way around inline size_t utf8ToWString(stringw &destination, const stringc &source)
static inline size_t wStringToMultibyte(string<c8>& destination, const wchar_t* source)
{ {
const u32 s = source ? (u32)wcslen(source) : 0; return utf8ToWString(destination, source.c_str());
return wStringToMultibyte(destination, source, s);
} }
//! Same as multibyteToWString, but the other way around inline size_t wStringToUTF8(stringc &destination, const wchar_t *source)
static size_t wStringToMultibyte(string<c8>& destination, const wchar_t* source, u32 sourceSize)
{ {
if ( sourceSize ) std::wstring_convert<std::codecvt_utf8<wchar_t>> conv;
{ destination = conv.to_bytes(source);
destination.str.resize(sizeof(wchar_t)*sourceSize+1); return destination.size();
#if defined(_MSC_VER) }
#pragma warning(push)
#pragma warning(disable: 4996) // 'wcstombs': This function or variable may be unsafe. Consider using wcstombs_s instead. inline size_t wStringToUTF8(stringc &destination, const stringw &source)
#endif {
const size_t written = wcstombs(&destination[0], source, destination.size()); return wStringToUTF8(destination, source.c_str());
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
if ( written != (size_t)-1 )
{
destination.str.resize(written);
}
else
{
// Likely character which got converted until the invalid character was encountered are in destination now.
// And it seems even 0-terminated, but I found no documentation anywhere that this (the 0-termination) is guaranteed :-(
destination.clear();
}
return written;
}
else
{
destination.clear();
return 0;
}
} }
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_TYPES_H_INCLUDED__ #pragma once
#define __IRR_TYPES_H_INCLUDED__
#include <stdint.h> #include <stdint.h>
@ -120,4 +119,3 @@ code like 'code', but some generate warnings so we use this macro here */
((irr::u32)(irr::u8)(c0) | ((irr::u32)(irr::u8)(c1) << 8) | \ ((irr::u32)(irr::u8)(c0) | ((irr::u32)(irr::u8)(c1) << 8) | \
((irr::u32)(irr::u8)(c2) << 16) | ((irr::u32)(irr::u8)(c3) << 24 )) ((irr::u32)(irr::u8)(c2) << 16) | ((irr::u32)(irr::u8)(c3) << 24 ))
#endif // __IRR_TYPES_H_INCLUDED__

View File

@ -597,7 +597,7 @@ public:
return difference_type(); return difference_type();
_Iter i = iter; _Iter i = iter;
difference_type ret; difference_type ret{};
// Walk up. // Walk up.
if (pos > i.pos) if (pos > i.pos)

View File

@ -30,10 +30,8 @@
#define __IRRLICHT_H_INCLUDED__ #define __IRRLICHT_H_INCLUDED__
#include "aabbox3d.h" #include "aabbox3d.h"
#include "CIndexBuffer.h"
#include "CMeshBuffer.h" #include "CMeshBuffer.h"
#include "coreutil.h" #include "coreutil.h"
#include "CVertexBuffer.h"
#include "dimension2d.h" #include "dimension2d.h"
#include "ECullingTypes.h" #include "ECullingTypes.h"
#include "EDebugSceneTypes.h" #include "EDebugSceneTypes.h"
@ -255,8 +253,7 @@ namespace irr
//! Creates an Irrlicht device. The Irrlicht device is the root object for using the engine. //! Creates an Irrlicht device. The Irrlicht device is the root object for using the engine.
/** If you need more parameters to be passed to the creation of the Irrlicht Engine device, /** If you need more parameters to be passed to the creation of the Irrlicht Engine device,
use the createDeviceEx() function. use the createDeviceEx() function.
\param driverType: Type of the video driver to use. This can currently be video::EDT_NULL, \param driverType: Type of the video driver to use.
video::EDT_SOFTWARE, video::EDT_BURNINGSVIDEO, video::EDT_DIRECT3D9 and video::EDT_OPENGL.
\param windowSize: Size of the window or the video mode in fullscreen mode. \param windowSize: Size of the window or the video mode in fullscreen mode.
\param bits: Bits per pixel in fullscreen mode. Ignored if windowed mode. \param bits: Bits per pixel in fullscreen mode. Ignored if windowed mode.
\param fullscreen: Should be set to true if the device should run in fullscreen. Otherwise \param fullscreen: Should be set to true if the device should run in fullscreen. Otherwise
@ -280,16 +277,6 @@ namespace irr
bool vsync = false, bool vsync = false,
IEventReceiver* receiver = 0); IEventReceiver* receiver = 0);
//! typedef for Function Pointer
typedef IrrlichtDevice* (IRRCALLCONV *funcptr_createDevice )(
video::E_DRIVER_TYPE driverType,
const core::dimension2d<u32>& windowSize,
u32 bits,
bool fullscreen,
bool stencilbuffer,
bool vsync,
IEventReceiver* receiver);
//! Creates an Irrlicht device with the option to specify advanced parameters. //! Creates an Irrlicht device with the option to specify advanced parameters.
/** Usually you should used createDevice() for creating an Irrlicht Engine device. /** Usually you should used createDevice() for creating an Irrlicht Engine device.
@ -302,10 +289,6 @@ namespace irr
extern "C" IRRLICHT_API IrrlichtDevice* IRRCALLCONV createDeviceEx( extern "C" IRRLICHT_API IrrlichtDevice* IRRCALLCONV createDeviceEx(
const SIrrlichtCreationParameters& parameters); const SIrrlichtCreationParameters& parameters);
//! typedef for Function Pointer
typedef IrrlichtDevice* (IRRCALLCONV *funcptr_createDeviceEx )( const SIrrlichtCreationParameters& parameters );
// THE FOLLOWING IS AN EMPTY LIST OF ALL SUB NAMESPACES // THE FOLLOWING IS AN EMPTY LIST OF ALL SUB NAMESPACES
// EXISTING ONLY FOR THE DOCUMENTATION SOFTWARE DOXYGEN. // EXISTING ONLY FOR THE DOCUMENTATION SOFTWARE DOXYGEN.

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_LINE_2D_H_INCLUDED__ #pragma once
#define __IRR_LINE_2D_H_INCLUDED__
#include "irrTypes.h" #include "irrTypes.h"
#include "vector2d.h" #include "vector2d.h"
@ -66,7 +65,7 @@ class line2d
vector2d<T> getVector() const { return vector2d<T>( end.X - start.X, end.Y - start.Y); } vector2d<T> getVector() const { return vector2d<T>( end.X - start.X, end.Y - start.Y); }
/*! Check if this segment intersects another segment, /*! Check if this segment intersects another segment,
or if segments are coincindent (colinear). */ or if segments are coincident (colinear). */
bool intersectAsSegments( const line2d<T>& other) const bool intersectAsSegments( const line2d<T>& other) const
{ {
// Taken from: // Taken from:
@ -83,7 +82,7 @@ class line2d
if (o1 != o2 && o3 != o4) if (o1 != o2 && o3 != o4)
return true; return true;
// Special Cases to check if segments are coolinear // Special Cases to check if segments are colinear
if (o1 == 0 && other.start.isBetweenPoints( start, end)) return true; if (o1 == 0 && other.start.isBetweenPoints( start, end)) return true;
if (o2 == 0 && other.end.isBetweenPoints( start, end)) return true; if (o2 == 0 && other.end.isBetweenPoints( start, end)) return true;
if (o3 == 0 && start.isBetweenPoints( other.start, other.end)) return true; if (o3 == 0 && start.isBetweenPoints( other.start, other.end)) return true;
@ -355,5 +354,4 @@ class line2d
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_LINE_3D_H_INCLUDED__ #pragma once
#define __IRR_LINE_3D_H_INCLUDED__
#include "irrTypes.h" #include "irrTypes.h"
#include "vector3d.h" #include "vector3d.h"
@ -140,5 +139,4 @@ class line3d
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_MATRIX_H_INCLUDED__ #pragma once
#define __IRR_MATRIX_H_INCLUDED__
#include "irrMath.h" #include "irrMath.h"
#include "vector3d.h" #include "vector3d.h"
@ -278,13 +277,6 @@ namespace core
void transformPlane( const core::plane3d<f32> &in, core::plane3d<f32> &out) const; void transformPlane( const core::plane3d<f32> &in, core::plane3d<f32> &out) const;
//! Transforms a axis aligned bounding box //! Transforms a axis aligned bounding box
/** The result box of this operation may not be accurate at all. For
correct results, use transformBoxEx() */
void transformBox(core::aabbox3d<f32>& box) const;
//! Transforms a axis aligned bounding box
/** The result box of this operation should be accurate, but this operation
is slower than transformBox(). */
void transformBoxEx(core::aabbox3d<f32>& box) const; void transformBoxEx(core::aabbox3d<f32>& box) const;
//! Multiplies this matrix by a 1x4 matrix //! Multiplies this matrix by a 1x4 matrix
@ -963,7 +955,7 @@ namespace core
// We assume the matrix uses rotations instead of negative scaling 2 axes. // We assume the matrix uses rotations instead of negative scaling 2 axes.
// Otherwise it fails even for some simple cases, like rotating around // Otherwise it fails even for some simple cases, like rotating around
// 2 axes by 180<EFBFBD> which getScale thinks is a negative scaling. // 2 axes by 180° which getScale thinks is a negative scaling.
if (scale.Y<0 && scale.Z<0) if (scale.Y<0 && scale.Z<0)
{ {
scale.Y =-scale.Y; scale.Y =-scale.Y;
@ -1278,22 +1270,6 @@ namespace core
transformPlane( out ); transformPlane( out );
} }
//! Transforms the edge-points of a bounding box
//! Deprecated as it's usually not what people need (regards only 2 corners, but other corners might be outside the box after transformation)
//! Use transformBoxEx instead.
template <class T>
_IRR_DEPRECATED_ inline void CMatrix4<T>::transformBox(core::aabbox3d<f32>& box) const
{
#if defined ( USE_MATRIX_TEST )
if (isIdentity())
return;
#endif
transformVect(box.MinEdge);
transformVect(box.MaxEdge);
box.repair();
}
//! Transforms a axis aligned bounding box more accurately than transformBox() //! Transforms a axis aligned bounding box more accurately than transformBox()
template <class T> template <class T>
inline void CMatrix4<T>::transformBoxEx(core::aabbox3d<f32>& box) const inline void CMatrix4<T>::transformBoxEx(core::aabbox3d<f32>& box) const
@ -2080,7 +2056,7 @@ namespace core
core::vector3df v(vs); core::vector3df v(vs);
v.normalize(); v.normalize();
// cosinus angle // cosine angle
T ca = f.dotProduct(t); T ca = f.dotProduct(t);
core::vector3df vt(v * (1 - ca)); core::vector3df vt(v * (1 - ca));
@ -2141,7 +2117,7 @@ namespace core
// axis multiplication by sin // axis multiplication by sin
const core::vector3df vs = look.crossProduct(from); const core::vector3df vs = look.crossProduct(from);
// cosinus angle // cosine angle
const f32 ca = from.dotProduct(look); const f32 ca = from.dotProduct(look);
core::vector3df vt(up * (1.f - ca)); core::vector3df vt(up * (1.f - ca));
@ -2386,5 +2362,4 @@ namespace core
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine" and the "irrXML" project. // This file is part of the "Irrlicht Engine" and the "irrXML" project.
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_PATH_H_INCLUDED__ #pragma once
#define __IRR_PATH_H_INCLUDED__
#include "irrString.h" #include "irrString.h"
@ -87,4 +86,3 @@ private:
} // io } // io
} // irr } // irr
#endif // __IRR_PATH_H_INCLUDED__

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_PLANE_3D_H_INCLUDED__ #pragma once
#define __IRR_PLANE_3D_H_INCLUDED__
#include "irrMath.h" #include "irrMath.h"
#include "vector3d.h" #include "vector3d.h"
@ -241,5 +240,4 @@ typedef plane3d<s32> plane3di;
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -5,8 +5,7 @@
//! As of Irrlicht 1.6, position2d is a synonym for vector2d. //! As of Irrlicht 1.6, position2d is a synonym for vector2d.
/** You should consider position2d to be deprecated, and use vector2d by preference. */ /** You should consider position2d to be deprecated, and use vector2d by preference. */
#ifndef __IRR_POSITION_H_INCLUDED__ #pragma once
#define __IRR_POSITION_H_INCLUDED__
#include "vector2d.h" #include "vector2d.h"
@ -28,5 +27,4 @@ typedef vector2d<s32> position2di;
// ...and use a #define to catch the rest, for (e.g.) position2d<f64> // ...and use a #define to catch the rest, for (e.g.) position2d<f64>
#define position2d vector2d #define position2d vector2d
#endif // __IRR_POSITION_H_INCLUDED__

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_QUATERNION_H_INCLUDED__ #pragma once
#define __IRR_QUATERNION_H_INCLUDED__
#include "irrTypes.h" #include "irrTypes.h"
#include "irrMath.h" #include "irrMath.h"
@ -720,6 +719,8 @@ inline core::quaternion& quaternion::makeIdentity()
inline core::quaternion& quaternion::rotationFromTo(const vector3df& from, const vector3df& to) inline core::quaternion& quaternion::rotationFromTo(const vector3df& from, const vector3df& to)
{ {
// Based on Stan Melax's article in Game Programming Gems // Based on Stan Melax's article in Game Programming Gems
// Optimized by Robert Eisele: https://raw.org/proof/quaternion-from-two-vectors
// Copy, since cannot modify local // Copy, since cannot modify local
vector3df v0 = from; vector3df v0 = from;
vector3df v1 = to; vector3df v1 = to;
@ -744,15 +745,12 @@ inline core::quaternion& quaternion::rotationFromTo(const vector3df& from, const
return set(axis.X, axis.Y, axis.Z, 0).normalize(); return set(axis.X, axis.Y, axis.Z, 0).normalize();
} }
const f32 s = sqrtf( (1+d)*2 ); // optimize inv_sqrt const vector3df c = v0.crossProduct(v1);
const f32 invs = 1.f / s; return set(c.X, c.Y, c.Z, 1 + d).normalize();
const vector3df c = v0.crossProduct(v1)*invs;
return set(c.X, c.Y, c.Z, s * 0.5f).normalize();
} }
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_RECT_H_INCLUDED__ #pragma once
#define __IRR_RECT_H_INCLUDED__
#include "irrTypes.h" #include "irrTypes.h"
#include "dimension2d.h" #include "dimension2d.h"
@ -284,5 +283,4 @@ namespace core
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_TRIANGLE_3D_H_INCLUDED__ #pragma once
#define __IRR_TRIANGLE_3D_H_INCLUDED__
#include "vector3d.h" #include "vector3d.h"
#include "line3d.h" #include "line3d.h"
@ -100,8 +99,7 @@ namespace core
//! Check if a point is inside the triangle (border-points count also as inside) //! Check if a point is inside the triangle (border-points count also as inside)
/** This method uses a barycentric coordinate system. /** This method uses a barycentric coordinate system.
It is faster than isPointInside but is more susceptible to floating point rounding It is faster than isPointInside but is more susceptible to floating point rounding
errors. This will especially be noticeable when the FPU is in single precision mode errors.
(which is for example set on default by Direct3D).
\param p Point to test. Assumes that this point is already \param p Point to test. Assumes that this point is already
on the plane of the triangle. on the plane of the triangle.
\return True if point is inside the triangle, otherwise false. */ \return True if point is inside the triangle, otherwise false. */
@ -275,5 +273,4 @@ namespace core
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_POINT_2D_H_INCLUDED__ #pragma once
#define __IRR_POINT_2D_H_INCLUDED__
#include "irrMath.h" #include "irrMath.h"
#include "dimension2d.h" #include "dimension2d.h"
@ -143,7 +142,7 @@ public:
bool nearlyParallel( const vector2d<T> & other, const T factor = relativeErrorFactor<T>()) const bool nearlyParallel( const vector2d<T> & other, const T factor = relativeErrorFactor<T>()) const
{ {
// https://eagergames.wordpress.com/2017/04/01/fast-parallel-lines-and-vectors-test/ // https://eagergames.wordpress.com/2017/04/01/fast-parallel-lines-and-vectors-test/
// if a || b then a.x/a.y = b.x/b.y (similiar triangles) // if a || b then a.x/a.y = b.x/b.y (similar triangles)
// if a || b then either both x are 0 or both y are 0. // if a || b then either both x are 0 or both y are 0.
return equalsRelative( X*other.Y, other.X* Y, factor) return equalsRelative( X*other.Y, other.X* Y, factor)
@ -432,5 +431,4 @@ struct hash<irr::core::vector2d<T> >
} }
#endif

View File

@ -2,8 +2,7 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_POINT_3D_H_INCLUDED__ #pragma once
#define __IRR_POINT_3D_H_INCLUDED__
#include "irrMath.h" #include "irrMath.h"
@ -155,7 +154,7 @@ namespace core
//! Calculates the cross product with another vector. //! Calculates the cross product with another vector.
/** \param p Vector to multiply with. /** \param p Vector to multiply with.
\return Crossproduct of this vector with p. */ \return Cross product of this vector with p. */
vector3d<T> crossProduct(const vector3d<T>& p) const vector3d<T> crossProduct(const vector3d<T>& p) const
{ {
return vector3d<T>(Y * p.Z - Z * p.Y, Z * p.X - X * p.Z, X * p.Y - Y * p.X); return vector3d<T>(Y * p.Z - Z * p.Y, Z * p.X - X * p.Z, X * p.Y - Y * p.X);
@ -207,7 +206,10 @@ namespace core
} }
//! Rotates the vector by a specified number of degrees around the Y axis and the specified center. //! Rotates the vector by a specified number of degrees around the Y axis and the specified center.
/** \param degrees Number of degrees to rotate around the Y axis. /** CAREFUL: For historical reasons rotateXZBy uses a right-handed rotation
(maybe to make it more similar to the 2D vector rotations which are counterclockwise).
To have this work the same way as rest of Irrlicht (nodes, matrices, other rotateBy functions) pass -1*degrees in here.
\param degrees Number of degrees to rotate around the Y axis.
\param center The center of the rotation. */ \param center The center of the rotation. */
void rotateXZBy(f64 degrees, const vector3d<T>& center=vector3d<T>()) void rotateXZBy(f64 degrees, const vector3d<T>& center=vector3d<T>())
{ {
@ -485,5 +487,4 @@ struct hash<irr::core::vector3d<T> >
} }
#endif

View File

@ -1,235 +0,0 @@
==========================================================================
The Irrlicht Engine SDK version 1.9
==========================================================================
Welcome to the Irrlicht Engine SDK.
Content of this file:
1. Directory Structure Overview
2. How To Start
3. Requirements
4. Release Notes
5. License
6. Contact
==========================================================================
1. Directory Structure Overview
==========================================================================
You will find some directories after uncompressing the archive of the
SDK. These are:
\bin The compiled library Irrlicht.DLL and some compiled demo
and example applications, just start them to see the
Irrlicht Engine in action. Windows only.
\doc Documentation of the Irrlicht Engine.
\examples Examples and tutorials showing how to use the engine with
C++.
\include Header files to include when programming with the engine.
\lib Libs to link with your programs when using the engine.
\media Graphics and sound resources for the demo applications and
examples.
\source The source code of the Irrlicht Engine. This code is
not needed to develop applications with the engine,
but it is included to enable recompilation and
debugging, if necessary.
\tools Useful tools (with sourcecode) for the engine.
==========================================================================
2. How to start
==========================================================================
To see the engine in action in Windows, just go to the \bin\Win32-VisualStudio
directory, and start some applications. There should also be an
application named Demo.exe which should show the most
interesting features of Irrlicht.
To start developing own applications and games with the engine take
a look at the 01.HelloWorld example in the \examples directory.
There is also a .html file with a tutorial which should be
easily comprehensible.
The Irrlicht Engine is a static lib under linux. A precompiled version can be
generated from the sources using the Makefile in source/Irrlicht. Run 'make' in
that subfolder. After this you should be able to 'make' all
example applications in /examples by calling the buildAllExamples script. You
can run the examples then from the bin folder.
It is also possible to use Irrlicht as shared object
(libIrrlicht.so.versionNumber). Use the proper makefile target for this by
running 'make sharedlib' in the source folder. See the Makefile for details.
For OSX you can find an XCode project file in source/Irrlicht/MacOSX. This will
build the libIrrlicht.a library necessary to create the apps.
==========================================================================
3. Requirements
==========================================================================
You can use one of the following compilers/IDEs to develop applications
with Irrlicht or recompile the engine. However, other compilers/IDEs may
work as well, we simply didn't test them.
* gcc 4.x
* Visual Studio 2010(10.0)-2013(12.0)
* Code::Blocks (& gcc or visual studio toolkit)
If you ever want to (re)compile the engine yourself (which means you don't
want to use the precompiled version) you need the following:
* Windows:
* Needed: PlatformSDK (which usually comes with all IDEs, download
it separately for MSVC Express 2005)
* Optional: DirectX SDK, for D3D9 support
* Optional: DirectX SDK prior to May 2006, for D3D8 support
* Linux:
* Needed: XServer with include files
* Optional: OpenGL headers and libraries (libGL.so) for OpenGL support
GLX +
XF86VidMode [package x11proto-xf86vidmode-dev] or XRandr
(X11 support libraries, the latter two for fullscreen mode)
* OSX:
* Needed: XCode and Cocoa framework
* Needed: OpenGL headers and libraries
==========================================================================
4. Release Notes
==========================================================================
Informations about changes in this new version of the engine can be
found in changes.txt.
Please note that the textures, 3D models and levels are copyright
by their authors and not covered by the Irrlicht engine license.
==========================================================================
5. License
==========================================================================
The license of the Irrlicht Engine is based on the zlib/libpng license.
Even though this license does not require you to mention that you are
using the Irrlicht Engine in your product, an acknowledgement
would be highly appreciated.
Please note that the Irrlicht Engine is based in part on the work of
the Independent JPEG Group, the zlib, and libpng. This means that if you use
the Irrlicht Engine in your product, you must acknowledge somewhere
in your documentation that you've used the IJG code and libpng. It would
also be nice to mention that you use the Irrlicht Engine and the zlib.
See the README files in the jpeglib and the zlib for
further informations.
The Irrlicht Engine License
===========================
Copyright (C) 2002-2012 Nikolaus Gebhardt
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgement in the product documentation would be
appreciated but is not required.
2. Altered source versions must be clearly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
==========================================================================
6. Contact
==========================================================================
If you have problems, questions or suggestions, please visit the
official homepage of the Irrlicht Engine:
http://irrlicht.sourceforge.net
You will find forums, bugtrackers, patches, tutorials, and other stuff
which will help you out.
If want to contact the team of the engine, please send an email to
Nikolaus Gebhardt:
irrlicht@users.sourceforge.net
Please also not that parts of the engine have been written or contributed
by other people. Especially: (There are probably more people, sorry if I forgot one.
See http://irrlicht.sourceforge.net/author.html for more informations)
Christian Stehno (hybrid) Contribution Coordinator/Developer
Michael Zeilfelder (cutealien) Developer
Patryk Nadrowski (Nadro) Developer
Yoran Bosman (Yoran) Webserver administrator
Gareth Davidson (bitplane) Developer/ Forum admin
Thomas Alten (burningwater) Wrote the burningsvideo software rasterizer
Luke P. Hoschke (luke) Wrote the b3d loader, the new animation system, VBOs and other things
Colin MacDonald (rogerborg) All hands person
Ahmed Hilali (blindside) The shader and advanced effects man
Dean Wadsworth (varmint) OSX port maintainer and game developer
Alvaro F. Celis (afecelis) Lots of work in the community, for example video tutorials about Irrlicht, forum admin
John Goewert (Saigumi) Wrote some tutorials for the Irrlicht Engine and doing admin stuff
Jam Takes care of moderating the forums and keeps them clean from those evil spammers.
Many others (this list hasn't been updated in a while, but they are often mentioned in changes.txt)
Etienne Petitjean wrote the MacPort of the engine
Mark Jeacocke Wrote lots of helpful comments and ideas in the forums and per email.
Julio Gorg<72> Created the 'Unofficial DirectX 9.0 Driver for the Irrlicht Engine'
Andy Spurgeon Wrote the Dev-Cpp tutorial.
Andr<64> Simon Wrote the Codewarrior tutorial.
KnightToFlight Created the unoffical terrain renderer addon for the Irrlicht Engine.
Jon Pry Wrote the code to load compressed TGA files.
Matthew Couch Wrote the tokamak integration tutorial.
Max Winkel Wrote the splitscreen tutorial.
Gorgon Zola Wrote the ODE integration tutorial.
Dean P. Macri Sent in code for curved surfaces and PCX Loading.
Sirshane Made several bug fixes, sent in code for making the mouse cursor invisible in Linux.
Matthias Gall Sent in code for a spline scene node animator and reported lots of bugs.
Mario Gruber Suggested triangle fan drawing and sent in code for this.
Ariaci Spotted out a bug in the ATI driver.
Dr Andros C Bragianos Improved texture mapping in cube scene node.
Philipp Dortmann Sent in code for stencil buffer support for OpenGL.
Jerome Nichols Created the Irrlicht/Ruby interface located at irr.rubyforge.org
Vash TheStampede Sent code for missing Draw2DLine() implementations
MattyBoy XBOX support suggestions
Oliver Klems createImageFromData() method suggestion/implementation
Jox really, really a lot of bug fixes, and the LMTS file loader
Zola Quaternion method additions
Tomasz Nowakowski various bug fixes
Nicholas Bray stencil shadow bug fixes with OpenGL
REAPER mouswheel events for scrollbar
Calimero various bug fixes like vector2d operators
Haddock bugfix in the linked list
G.o.D XML parser fix
Erik Zilli Translated some of the tutorials from my stuttering english into real english. :)
Martin Piskernig Linux bugfixing and testing
Soconne Wrote the original terrain renderer were Irrlichts terrain renderer of Irrlicht is based on it.
Spintz GeoMipMap scene node, terrain renderer of Irrlicht is based on it.
Murphy McCauley OCT file loader, MIM tools
Saurav Mohapatra IrrCSM, and lots of addons, suggestions and bug reports
Zhuck Dimitry My3D Tools
Terry Welsh Allowed me to use the textures of his 'Parallax Mapping with Offset Limiting' paper for the parallax demo of Irrlicht
rt Wrote the original .png loader for Irrlicht
Salvatore Russo Wrote the original .dmf loader for Irrlicht
Vox Various bug reports and fixes
atomice Contributed code for a ms3d loader enhancement
William Finlayson OpenGL RTT, GLSL support and the reflection 2 layer material for OpenGL.
Delight Various code contributions for Irrlicht.NET (particle system, basic shader support and more)
Michael Zoech Improved GLSL support
Jean-loup Gailly, Mark Adler Created the zlib and libpng
Guy Eric Schalnat, Andreas Dilger, Glenn Randers-Pehrson and others Created libpng
The Independent JPEG Group Created JPEG lib
Dr Brian Gladman AES Created aesGladman

View File

@ -1,2 +0,0 @@
You might have to recompile the engine to get library files in here.
Check the readme.txt in the corresponding bin folders for more information.

View File

@ -1,2 +0,0 @@
You might have to recompile the engine to get library files in here.
Check the readme.txt in the corresponding bin folders for more information.

View File

@ -1,2 +0,0 @@
You might have to recompile the engine to get library files in here.
Check the readme.txt in the corresponding bin folders for more information.

View File

@ -1,2 +0,0 @@
You might have to recompile the engine to get library files in here.
Check the readme.txt in the corresponding bin folders for more information.

View File

@ -1,6 +0,0 @@
This branch is used for development of the OpenGL-ES drivers for Irrlicht.
There will be drivers for ogl-es 1.x and 2.x at some time, but we'll start
with 1.x first. Both drivers will be separate drivers, loosely based on the
OpenGL driver.
The branch is based on SVN/trunk and will be updated only very slowly. It's
not intended for regular use besides when working with ogl-es development.

View File

@ -4,9 +4,14 @@
variant=win32 variant=win32
[[ "$(basename "$CXX")" == "x86_64-"* ]] && variant=win64 [[ "$(basename "$CXX")" == "x86_64-"* ]] && variant=win64
with_sdl=0
[[ "$extras" == *"-sdl"* ]] && with_sdl=1
#with_gl3=0
#[[ "$extras" == *"-gl3"* ]] && with_gl3=1
libjpeg_version=2.1.5.1 libjpeg_version=2.1.5.1
libpng_version=1.6.39 libpng_version=1.6.39
sdl2_version=2.28.1
zlib_version=1.2.13 zlib_version=1.2.13
mkdir -p libs mkdir -p libs
@ -16,10 +21,13 @@ libs=$PWD
wget "http://minetest.kitsunemimi.pw/libjpeg-$libjpeg_version-$variant.zip" -O libjpeg.zip wget "http://minetest.kitsunemimi.pw/libjpeg-$libjpeg_version-$variant.zip" -O libjpeg.zip
[ -e libpng.zip ] || \ [ -e libpng.zip ] || \
wget "http://minetest.kitsunemimi.pw/libpng-$libpng_version-$variant.zip" -O libpng.zip wget "http://minetest.kitsunemimi.pw/libpng-$libpng_version-$variant.zip" -O libpng.zip
[[ $with_sdl -eq 0 || -e sdl2.zip ]] || \
wget "http://minetest.kitsunemimi.pw/sdl2-$sdl2_version-$variant.zip" -O sdl2.zip
[ -e zlib.zip ] || \ [ -e zlib.zip ] || \
wget "http://minetest.kitsunemimi.pw/zlib-$zlib_version-$variant.zip" -O zlib.zip wget "http://minetest.kitsunemimi.pw/zlib-$zlib_version-$variant.zip" -O zlib.zip
[ -d libjpeg ] || unzip -o libjpeg.zip -d libjpeg [ -d libjpeg ] || unzip -o libjpeg.zip -d libjpeg
[ -d libpng ] || unzip -o libpng.zip -d libpng [ -d libpng ] || unzip -o libpng.zip -d libpng
[[ $with_sdl -eq 0 || -d sdl2 ]] || unzip -o sdl2.zip -d sdl2
[ -d zlib ] || unzip -o zlib.zip -d zlib [ -d zlib ] || unzip -o zlib.zip -d zlib
popd popd
@ -32,6 +40,11 @@ tmp=(
-DZLIB_LIBRARY=$libs/zlib/lib/libz.dll.a \ -DZLIB_LIBRARY=$libs/zlib/lib/libz.dll.a \
-DZLIB_INCLUDE_DIR=$libs/zlib/include -DZLIB_INCLUDE_DIR=$libs/zlib/include
) )
[ $with_sdl -eq 1 ] && tmp+=(
-DUSE_SDL2=ON
-DCMAKE_PREFIX_PATH=$libs/sdl2/lib/cmake
)
#[ $with_gl3 -eq 1 ] && tmp+=(-DENABLE_OPENGL=OFF -DENABLE_OPENGL3=ON)
cmake . "${tmp[@]}" cmake . "${tmp[@]}"
make -j$(nproc) make -j$(nproc)
@ -41,8 +54,9 @@ if [ "$1" = "package" ]; then
# strip library # strip library
"${CXX%-*}-strip" --strip-unneeded _install/usr/local/lib/*.dll "${CXX%-*}-strip" --strip-unneeded _install/usr/local/lib/*.dll
# bundle the DLLs that are specific to Irrlicht (kind of a hack) # bundle the DLLs that are specific to Irrlicht (kind of a hack)
cp -p $libs/*/bin/lib{jpeg,png}*.dll _install/usr/local/lib/ shopt -s nullglob
cp -p $libs/*/bin/{libjpeg,libpng,SDL}*.dll _install/usr/local/lib/
# create a ZIP # create a ZIP
(cd _install/usr/local; zip -9r "$OLDPWD"/irrlicht-$variant.zip -- *) (cd _install/usr/local; zip -9r "$OLDPWD/irrlicht-$variant$extras.zip" -- *)
fi fi
exit 0 exit 0

View File

@ -3,7 +3,6 @@
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifdef _IRR_COMPILE_ANDROID_ASSET_READER_
#include "CAndroidAssetReader.h" #include "CAndroidAssetReader.h"
@ -106,4 +105,3 @@ void CAndroidAssetFileArchive::addDirectoryToFileList(const io::path &dirname_)
} // end namespace io } // end namespace io
} // end namespace irr } // end namespace irr
#endif // _IRR_COMPILE_ANDROID_ASSET_READER_

View File

@ -4,9 +4,6 @@
#pragma once #pragma once
#ifdef _IRR_COMPILE_ANDROID_ASSET_READER_
#include "IReadFile.h" #include "IReadFile.h"
#include "IFileArchive.h" #include "IFileArchive.h"
#include "CFileList.h" #include "CFileList.h"
@ -61,4 +58,3 @@ namespace io
} // end namespace io } // end namespace io
} // end namespace irr } // end namespace irr
#endif // _IRR_COMPILE_ANDROID_ASSET_READER_

View File

@ -2,9 +2,6 @@
// This file is part of the "Irrlicht Engine". // This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h // For conditions of distribution and use, see copyright notice in irrlicht.h
#ifdef _IRR_COMPILE_ANDROID_ASSET_READER_
#include "CAndroidAssetReader.h" #include "CAndroidAssetReader.h"
#include "CReadFile.h" #include "CReadFile.h"
@ -69,4 +66,3 @@ const io::path& CAndroidAssetReader::getFileName() const
} // end namespace io } // end namespace io
} // end namespace irr } // end namespace irr
#endif // _IRR_COMPILE_ANDROID_ASSET_READER_

View File

@ -4,9 +4,6 @@
#pragma once #pragma once
#ifdef _IRR_COMPILE_ANDROID_ASSET_READER_
#include "IReadFile.h" #include "IReadFile.h"
struct AAssetManager; struct AAssetManager;
@ -66,4 +63,3 @@ namespace io
} // end namespace io } // end namespace io
} // end namespace irr } // end namespace irr
#endif // _IRR_COMPILE_ANDROID_ASSET_READER_

View File

@ -5,8 +5,6 @@
#include "CIrrDeviceAndroid.h" #include "CIrrDeviceAndroid.h"
#ifdef _IRR_COMPILE_WITH_ANDROID_DEVICE_
#include "os.h" #include "os.h"
#include "CFileSystem.h" #include "CFileSystem.h"
#include "CAndroidAssetReader.h" #include "CAndroidAssetReader.h"
@ -535,11 +533,7 @@ void CIrrDeviceAndroid::createDriver()
case video::EDT_NULL: case video::EDT_NULL:
VideoDriver = video::createNullDriver(FileSystem, CreationParams.WindowSize); VideoDriver = video::createNullDriver(FileSystem, CreationParams.WindowSize);
break; break;
case video::EDT_SOFTWARE:
case video::EDT_BURNINGSVIDEO:
case video::EDT_OPENGL: case video::EDT_OPENGL:
case video::DEPRECATED_EDT_DIRECT3D8_NO_LONGER_EXISTS:
case video::EDT_DIRECT3D9:
os::Printer::log("This driver is not available in Android. Try OpenGL ES 1.0 or ES 2.0.", ELL_ERROR); os::Printer::log("This driver is not available in Android. Try OpenGL ES 1.0 or ES 2.0.", ELL_ERROR);
break; break;
default: default:
@ -862,5 +856,3 @@ bool CIrrDeviceAndroid::isGyroscopeAvailable()
} }
} // end namespace irr } // end namespace irr
#endif

View File

@ -5,7 +5,6 @@
#pragma once #pragma once
#ifdef _IRR_COMPILE_WITH_ANDROID_DEVICE_
#include "CIrrDeviceStub.h" #include "CIrrDeviceStub.h"
#include "IrrlichtDevice.h" #include "IrrlichtDevice.h"
@ -98,4 +97,3 @@ namespace irr
} // end namespace irr } // end namespace irr
#endif // _IRR_COMPILE_WITH_ANDROID_DEVICE_

View File

@ -3,8 +3,6 @@
#include "CKeyEventWrapper.h" #include "CKeyEventWrapper.h"
#ifdef _IRR_COMPILE_WITH_ANDROID_DEVICE_
#include "os.h" #include "os.h"
namespace irr namespace irr
@ -58,6 +56,3 @@ int CKeyEventWrapper::getUnicodeChar(int metaState)
} // namespace jni } // namespace jni
} // namespace irr } // namespace irr
#endif // _IRR_COMPILE_WITH_ANDROID_DEVICE_

View File

@ -3,8 +3,6 @@
#pragma once #pragma once
#ifdef _IRR_COMPILE_WITH_ANDROID_DEVICE_
#include <jni.h> #include <jni.h>
struct android_app; struct android_app;
@ -35,5 +33,3 @@ private:
} // namespace jni } // namespace jni
} // namespace irr } // namespace irr
#endif // _IRR_COMPILE_WITH_ANDROID_DEVICE_

File diff suppressed because it is too large Load Diff

View File

@ -7,9 +7,7 @@
#include "ISceneManager.h" #include "ISceneManager.h"
#include "S3DVertex.h" #include "S3DVertex.h"
#include "os.h" #include "os.h"
#ifdef _IRR_COMPILE_WITH_SKINNED_MESH_SUPPORT_
#include "CSkinnedMesh.h" #include "CSkinnedMesh.h"
#endif
#include "IDummyTransformationSceneNode.h" #include "IDummyTransformationSceneNode.h"
#include "IBoneSceneNode.h" #include "IBoneSceneNode.h"
#include "IMaterialRenderer.h" #include "IMaterialRenderer.h"
@ -187,10 +185,6 @@ IMesh * CAnimatedMeshSceneNode::getMeshForCurrentFrame()
} }
else else
{ {
#ifndef _IRR_COMPILE_WITH_SKINNED_MESH_SUPPORT_
return 0;
#else
// As multiple scene nodes may be sharing the same skinned mesh, we have to // As multiple scene nodes may be sharing the same skinned mesh, we have to
// re-animate it every frame to ensure that this node gets the mesh that it needs. // re-animate it every frame to ensure that this node gets the mesh that it needs.
@ -223,7 +217,6 @@ IMesh * CAnimatedMeshSceneNode::getMeshForCurrentFrame()
} }
return skinnedMesh; return skinnedMesh;
#endif
} }
} }
@ -466,11 +459,6 @@ u32 CAnimatedMeshSceneNode::getMaterialCount() const
//! the corresponding joint, if the mesh in this scene node is a skinned mesh. //! the corresponding joint, if the mesh in this scene node is a skinned mesh.
IBoneSceneNode* CAnimatedMeshSceneNode::getJointNode(const c8* jointName) IBoneSceneNode* CAnimatedMeshSceneNode::getJointNode(const c8* jointName)
{ {
#ifndef _IRR_COMPILE_WITH_SKINNED_MESH_SUPPORT_
os::Printer::log("Compiled without _IRR_COMPILE_WITH_SKINNED_MESH_SUPPORT_", ELL_WARNING);
return 0;
#else
if (!Mesh || Mesh->getMeshType() != EAMT_SKINNED) if (!Mesh || Mesh->getMeshType() != EAMT_SKINNED)
{ {
os::Printer::log("No mesh, or mesh not of skinned mesh type", ELL_WARNING); os::Printer::log("No mesh, or mesh not of skinned mesh type", ELL_WARNING);
@ -496,7 +484,6 @@ IBoneSceneNode* CAnimatedMeshSceneNode::getJointNode(const c8* jointName)
} }
return JointChildSceneNodes[number]; return JointChildSceneNodes[number];
#endif
} }
@ -505,11 +492,6 @@ IBoneSceneNode* CAnimatedMeshSceneNode::getJointNode(const c8* jointName)
//! the corresponding joint, if the mesh in this scene node is a skinned mesh. //! the corresponding joint, if the mesh in this scene node is a skinned mesh.
IBoneSceneNode* CAnimatedMeshSceneNode::getJointNode(u32 jointID) IBoneSceneNode* CAnimatedMeshSceneNode::getJointNode(u32 jointID)
{ {
#ifndef _IRR_COMPILE_WITH_SKINNED_MESH_SUPPORT_
os::Printer::log("Compiled without _IRR_COMPILE_WITH_SKINNED_MESH_SUPPORT_", ELL_WARNING);
return 0;
#else
if (!Mesh || Mesh->getMeshType() != EAMT_SKINNED) if (!Mesh || Mesh->getMeshType() != EAMT_SKINNED)
{ {
os::Printer::log("No mesh, or mesh not of skinned mesh type", ELL_WARNING); os::Printer::log("No mesh, or mesh not of skinned mesh type", ELL_WARNING);
@ -525,23 +507,17 @@ IBoneSceneNode* CAnimatedMeshSceneNode::getJointNode(u32 jointID)
} }
return JointChildSceneNodes[jointID]; return JointChildSceneNodes[jointID];
#endif
} }
//! Gets joint count. //! Gets joint count.
u32 CAnimatedMeshSceneNode::getJointCount() const u32 CAnimatedMeshSceneNode::getJointCount() const
{ {
#ifndef _IRR_COMPILE_WITH_SKINNED_MESH_SUPPORT_
return 0;
#else
if (!Mesh || Mesh->getMeshType() != EAMT_SKINNED) if (!Mesh || Mesh->getMeshType() != EAMT_SKINNED)
return 0; return 0;
ISkinnedMesh *skinnedMesh=(ISkinnedMesh*)Mesh; ISkinnedMesh *skinnedMesh=(ISkinnedMesh*)Mesh;
return skinnedMesh->getJointCount(); return skinnedMesh->getJointCount();
#endif
} }
@ -702,9 +678,6 @@ void CAnimatedMeshSceneNode::setRenderFromIdentity(bool enable)
//! updates the joint positions of this mesh //! updates the joint positions of this mesh
void CAnimatedMeshSceneNode::animateJoints(bool CalculateAbsolutePositions) void CAnimatedMeshSceneNode::animateJoints(bool CalculateAbsolutePositions)
{ {
#ifndef _IRR_COMPILE_WITH_SKINNED_MESH_SUPPORT_
return;
#else
if (Mesh && Mesh->getMeshType() == EAMT_SKINNED ) if (Mesh && Mesh->getMeshType() == EAMT_SKINNED )
{ {
checkJoints(); checkJoints();
@ -776,17 +749,12 @@ void CAnimatedMeshSceneNode::animateJoints(bool CalculateAbsolutePositions)
} }
} }
} }
#endif
} }
/*! /*!
*/ */
void CAnimatedMeshSceneNode::checkJoints() void CAnimatedMeshSceneNode::checkJoints()
{ {
#ifndef _IRR_COMPILE_WITH_SKINNED_MESH_SUPPORT_
return;
#else
if (!Mesh || Mesh->getMeshType() != EAMT_SKINNED) if (!Mesh || Mesh->getMeshType() != EAMT_SKINNED)
return; return;
@ -803,7 +771,6 @@ void CAnimatedMeshSceneNode::checkJoints()
JointsUsed=true; JointsUsed=true;
JointMode=EJUOR_READ; JointMode=EJUOR_READ;
} }
#endif
} }
/*! /*!

View File

@ -274,7 +274,14 @@ bool CB3DMeshFileLoader::readChunkMESH(CSkinnedMesh::SJoint *inJoint)
{ {
scene::SSkinMeshBuffer *meshBuffer = AnimatedMesh->addMeshBuffer(); scene::SSkinMeshBuffer *meshBuffer = AnimatedMesh->addMeshBuffer();
if (brushID!=-1) if (brushID == -1)
{ /* ok */ }
else if (brushID < 0 || (u32)brushID >= Materials.size())
{
os::Printer::log("Illegal brush ID found", B3DFile->getFileName(), ELL_ERROR);
return false;
}
else
{ {
meshBuffer->Material=Materials[brushID].Material; meshBuffer->Material=Materials[brushID].Material;
} }
@ -354,7 +361,8 @@ bool CB3DMeshFileLoader::readChunkVRTS(CSkinnedMesh::SJoint *inJoint)
tex_coord_set_size = os::Byteswap::byteswap(tex_coord_set_size); tex_coord_set_size = os::Byteswap::byteswap(tex_coord_set_size);
#endif #endif
if (tex_coord_sets >= max_tex_coords || tex_coord_set_size >= 4) // Something is wrong if (tex_coord_sets < 0 || tex_coord_set_size < 0 ||
tex_coord_sets >= max_tex_coords || tex_coord_set_size >= 4) // Something is wrong
{ {
os::Printer::log("tex_coord_sets or tex_coord_set_size too big", B3DFile->getFileName(), ELL_ERROR); os::Printer::log("tex_coord_sets or tex_coord_set_size too big", B3DFile->getFileName(), ELL_ERROR);
return false; return false;
@ -458,13 +466,18 @@ bool CB3DMeshFileLoader::readChunkTRIS(scene::SSkinMeshBuffer *meshBuffer, u32 m
SB3dMaterial *B3dMaterial; SB3dMaterial *B3dMaterial;
if (triangle_brush_id != -1) if (triangle_brush_id == -1)
B3dMaterial = 0;
else if (triangle_brush_id < 0 || (u32)triangle_brush_id >= Materials.size())
{
os::Printer::log("Illegal material index found", B3DFile->getFileName(), ELL_ERROR);
return false;
}
else
{ {
B3dMaterial = &Materials[triangle_brush_id]; B3dMaterial = &Materials[triangle_brush_id];
meshBuffer->Material = B3dMaterial->Material; meshBuffer->Material = B3dMaterial->Material;
} }
else
B3dMaterial = 0;
const s32 memoryNeeded = B3dStack.getLast().length / sizeof(s32); const s32 memoryNeeded = B3dStack.getLast().length / sizeof(s32);
meshBuffer->Indices.reallocate(memoryNeeded + meshBuffer->Indices.size() + 1); meshBuffer->Indices.reallocate(memoryNeeded + meshBuffer->Indices.size() + 1);
@ -583,6 +596,12 @@ bool CB3DMeshFileLoader::readChunkBONE(CSkinnedMesh::SJoint *inJoint)
#endif #endif
globalVertexID += VerticesStart; globalVertexID += VerticesStart;
if (globalVertexID >= AnimatedVertices_VertexID.size())
{
os::Printer::log("Illegal vertex index found", B3DFile->getFileName(), ELL_ERROR);
return false;
}
if (AnimatedVertices_VertexID[globalVertexID]==-1) if (AnimatedVertices_VertexID[globalVertexID]==-1)
{ {
os::Printer::log("B3dMeshLoader: Weight has bad vertex id (no link to meshbuffer index found)"); os::Printer::log("B3dMeshLoader: Weight has bad vertex id (no link to meshbuffer index found)");
@ -1015,10 +1034,11 @@ bool CB3DMeshFileLoader::readChunkBRUS()
void CB3DMeshFileLoader::readString(core::stringc& newstring) void CB3DMeshFileLoader::readString(core::stringc& newstring)
{ {
newstring=""; newstring="";
while (B3DFile->getPos() <= B3DFile->getSize()) while (true)
{ {
c8 character; c8 character;
B3DFile->read(&character, sizeof(character)); if (B3DFile->read(&character, sizeof(character)) == 0)
return; // eof
if (character==0) if (character==0)
return; return;
newstring.append(character); newstring.append(character);

View File

@ -19,8 +19,7 @@ CCameraSceneNode::CCameraSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 i
: ICameraSceneNode(parent, mgr, id, position), : ICameraSceneNode(parent, mgr, id, position),
BoundingBox(core::vector3df(0, 0, 0)), // Camera has no size. Still not sure if FLT_MAX might be the better variant BoundingBox(core::vector3df(0, 0, 0)), // Camera has no size. Still not sure if FLT_MAX might be the better variant
Target(lookat), UpVector(0.0f, 1.0f, 0.0f), ZNear(1.0f), ZFar(3000.0f), Target(lookat), UpVector(0.0f, 1.0f, 0.0f), ZNear(1.0f), ZFar(3000.0f),
InputReceiverEnabled(true), TargetAndRotationAreBound(false), InputReceiverEnabled(true), TargetAndRotationAreBound(false)
HasD3DStyleProjectionMatrix(true)
{ {
#ifdef _DEBUG #ifdef _DEBUG
setDebugName("CCameraSceneNode"); setDebugName("CCameraSceneNode");
@ -36,7 +35,6 @@ CCameraSceneNode::CCameraSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 i
if ( d->getCurrentRenderTargetSize().Height ) if ( d->getCurrentRenderTargetSize().Height )
Aspect = (f32)d->getCurrentRenderTargetSize().Width / Aspect = (f32)d->getCurrentRenderTargetSize().Width /
(f32)d->getCurrentRenderTargetSize().Height; (f32)d->getCurrentRenderTargetSize().Height;
HasD3DStyleProjectionMatrix = d->getDriverType() != video::EDT_OPENGL;
} }
ViewArea.setFarNearDistance(ZFar - ZNear); ViewArea.setFarNearDistance(ZFar - ZNear);
@ -223,7 +221,7 @@ void CCameraSceneNode::setFOV(f32 f)
void CCameraSceneNode::recalculateProjectionMatrix() void CCameraSceneNode::recalculateProjectionMatrix()
{ {
ViewArea.getTransform ( video::ETS_PROJECTION ).buildProjectionMatrixPerspectiveFovLH(Fovy, Aspect, ZNear, ZFar, HasD3DStyleProjectionMatrix); ViewArea.getTransform ( video::ETS_PROJECTION ).buildProjectionMatrixPerspectiveFovLH(Fovy, Aspect, ZNear, ZFar, false);
IsOrthogonal = false; IsOrthogonal = false;
} }
@ -296,7 +294,7 @@ void CCameraSceneNode::recalculateViewArea()
core::matrix4 m(core::matrix4::EM4CONST_NOTHING); core::matrix4 m(core::matrix4::EM4CONST_NOTHING);
m.setbyproduct_nocheck(ViewArea.getTransform(video::ETS_PROJECTION), m.setbyproduct_nocheck(ViewArea.getTransform(video::ETS_PROJECTION),
ViewArea.getTransform(video::ETS_VIEW)); ViewArea.getTransform(video::ETS_VIEW));
ViewArea.setFrom(m, HasD3DStyleProjectionMatrix); ViewArea.setFrom(m, false);
} }

View File

@ -161,8 +161,6 @@ namespace scene
bool InputReceiverEnabled; bool InputReceiverEnabled;
bool TargetAndRotationAreBound; bool TargetAndRotationAreBound;
bool HasD3DStyleProjectionMatrix; // true: projection from 0 to w; false: -w to w
}; };
} // end namespace } // end namespace

View File

@ -22,9 +22,9 @@ namespace gui
CGUIComboBox::CGUIComboBox(IGUIEnvironment* environment, IGUIElement* parent, CGUIComboBox::CGUIComboBox(IGUIEnvironment* environment, IGUIElement* parent,
s32 id, core::rect<s32> rectangle) s32 id, core::rect<s32> rectangle)
: IGUIComboBox(environment, parent, id, rectangle), : IGUIComboBox(environment, parent, id, rectangle),
ListButton(0), SelectedText(0), ListBox(0), LastFocus(0), ListButton(nullptr), SelectedText(nullptr), ListBox(nullptr), LastFocus(nullptr),
Selected(-1), HAlign(EGUIA_UPPERLEFT), VAlign(EGUIA_CENTER), MaxSelectionRows(5), HasFocus(false), Selected(-1), HAlign(EGUIA_UPPERLEFT), VAlign(EGUIA_CENTER), MaxSelectionRows(5), HasFocus(false),
ActiveFont(0) ActiveFont(nullptr)
{ {
#ifdef _DEBUG #ifdef _DEBUG
setDebugName("CGUIComboBox"); setDebugName("CGUIComboBox");
@ -185,6 +185,15 @@ void CGUIComboBox::setSelected(s32 idx)
} }
//! Sets the selected item and emits a change event.
/** Set this to -1 if no item should be selected */
void CGUIComboBox::setAndSendSelected(s32 idx)
{
setSelected(idx);
sendSelectionChangedEvent();
}
//! called if an event happened. //! called if an event happened.
bool CGUIComboBox::OnEvent(const SEvent& event) bool CGUIComboBox::OnEvent(const SEvent& event)
{ {
@ -208,7 +217,7 @@ bool CGUIComboBox::OnEvent(const SEvent& event)
openCloseMenu(); openCloseMenu();
} }
ListButton->setPressed(ListBox == 0); ListButton->setPressed(ListBox == nullptr);
return true; return true;
} }
@ -361,7 +370,7 @@ void CGUIComboBox::sendSelectionChangedEvent()
event.EventType = EET_GUI_EVENT; event.EventType = EET_GUI_EVENT;
event.GUIEvent.Caller = this; event.GUIEvent.Caller = this;
event.GUIEvent.Element = 0; event.GUIEvent.Element = nullptr;
event.GUIEvent.EventType = EGET_COMBO_BOX_CHANGED; event.GUIEvent.EventType = EGET_COMBO_BOX_CHANGED;
Parent->OnEvent(event); Parent->OnEvent(event);
} }
@ -447,12 +456,23 @@ void CGUIComboBox::openCloseMenu()
// close list box // close list box
Environment->setFocus(this); Environment->setFocus(this);
ListBox->remove(); ListBox->remove();
ListBox = 0; ListBox = nullptr;
} }
else else
{ {
if (Parent) if (Parent) {
SEvent event;
event.EventType = EET_GUI_EVENT;
event.GUIEvent.Caller = this;
event.GUIEvent.Element = nullptr;
event.GUIEvent.EventType = EGET_LISTBOX_OPENED;
// Allow to prevent the listbox from opening.
if (Parent->OnEvent(event))
return;
Parent->bringToFront(this); Parent->bringToFront(this);
}
IGUISkin* skin = Environment->getSkin(); IGUISkin* skin = Environment->getSkin();
u32 h = Items.size(); u32 h = Items.size();

View File

@ -55,6 +55,10 @@ namespace gui
//! sets the selected item. Set this to -1 if no item should be selected //! sets the selected item. Set this to -1 if no item should be selected
void setSelected(s32 idx) override; void setSelected(s32 idx) override;
//! Sets the selected item and emits a change event.
/** Set this to -1 if no item should be selected */
void setAndSendSelected(s32 idx) override;
//! sets the text alignment of the text part //! sets the text alignment of the text part
void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical) override; void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical) override;

View File

@ -299,7 +299,7 @@ bool CGUIEditBox::processKey(const SEvent& event)
const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin; const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
core::stringc s; core::stringc s;
wStringToMultibyte(s, Text.subString(realmbgn, realmend - realmbgn)); wStringToUTF8(s, Text.subString(realmbgn, realmend - realmbgn));
Operator->copyToClipboard(s.c_str()); Operator->copyToClipboard(s.c_str());
} }
break; break;
@ -312,7 +312,7 @@ bool CGUIEditBox::processKey(const SEvent& event)
// copy // copy
core::stringc sc; core::stringc sc;
wStringToMultibyte(sc, Text.subString(realmbgn, realmend - realmbgn)); wStringToUTF8(sc, Text.subString(realmbgn, realmend - realmbgn));
Operator->copyToClipboard(sc.c_str()); Operator->copyToClipboard(sc.c_str());
if (isEnabled()) if (isEnabled())
@ -345,7 +345,7 @@ bool CGUIEditBox::processKey(const SEvent& event)
if (p) if (p)
{ {
irr::core::stringw widep; irr::core::stringw widep;
core::multibyteToWString(widep, p); core::utf8ToWString(widep, p);
if (MarkBegin == MarkEnd) if (MarkBegin == MarkEnd)
{ {
@ -1157,7 +1157,7 @@ bool CGUIEditBox::processMouse(const SEvent& event)
const c8 *inserted_text_utf8 = Operator->getTextFromPrimarySelection(); const c8 *inserted_text_utf8 = Operator->getTextFromPrimarySelection();
if (!inserted_text_utf8) if (!inserted_text_utf8)
return inserted_text; return inserted_text;
core::multibyteToWString(inserted_text, inserted_text_utf8); core::utf8ToWString(inserted_text, inserted_text_utf8);
return inserted_text; return inserted_text;
}()); }());
@ -1659,7 +1659,7 @@ void CGUIEditBox::setTextMarkers(s32 begin, s32 end)
const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin; const s32 realmend = MarkBegin < MarkEnd ? MarkEnd : MarkBegin;
core::stringc s; core::stringc s;
wStringToMultibyte(s, Text.subString(realmbgn, realmend - realmbgn)); wStringToUTF8(s, Text.subString(realmbgn, realmend - realmbgn));
Operator->copyToPrimarySelection(s.c_str()); Operator->copyToPrimarySelection(s.c_str());
} }

View File

@ -149,7 +149,7 @@ void CGUIEnvironment::loadBuiltInFont()
CGUIFont* font = new CGUIFont(this, DefaultFontName ); CGUIFont* font = new CGUIFont(this, DefaultFontName );
if (!font->load(file)) if (!font->load(file))
{ {
os::Printer::log("Error: Could not load built-in Font. Did you compile without the BMP loader?", ELL_ERROR); os::Printer::log("Error: Could not load built-in Font.", ELL_ERROR);
font->drop(); font->drop();
file->drop(); file->drop();
return; return;

View File

@ -623,7 +623,7 @@ void CGUIListBox::recalculateScrollPos()
if (!AutoScroll) if (!AutoScroll)
return; return;
const s32 selPos = (Selected == -1 ? TotalItemHeight : Selected * ItemHeight) - ScrollBar->getPos(); const s32 selPos = (getSelected() == -1 ? TotalItemHeight : getSelected() * ItemHeight) - ScrollBar->getPos();
if (selPos < 0) if (selPos < 0)
{ {

View File

@ -45,20 +45,32 @@ bool CImageLoaderBMP::isALoadableFileFormat(io::IReadFile* file) const
return headerID == 0x4d42; return headerID == 0x4d42;
} }
// UB-safe overflow check
static inline bool overflowCheck(const void *base, size_t offset, const void *end)
{
auto baseI = reinterpret_cast<uintptr_t>(base),
endI = reinterpret_cast<uintptr_t>(end);
return baseI > endI || offset >= (endI - baseI);
}
// check whether &p[0] to &p[_off - 1] can be accessed
#define CHECKP(_off) if ((_off) < 0 || overflowCheck(p, _off, pEnd)) goto exit
// same for d
#define CHECKD(_off) if ((_off) < 0 || overflowCheck(d, _off, destEnd)) goto exit
void CImageLoaderBMP::decompress8BitRLE(u8*& bmpData, s32 size, s32 width, s32 height, s32 pitch) const void CImageLoaderBMP::decompress8BitRLE(u8*& bmpData, s32 size, s32 width, s32 height, s32 pitch) const
{ {
u8* p = bmpData; u8* p = bmpData;
const u8* pEnd = bmpData + size;
u8* newBmp = new u8[(width+pitch)*height]; u8* newBmp = new u8[(width+pitch)*height];
u8* d = newBmp; u8* d = newBmp;
u8* destEnd = newBmp + (width+pitch)*height; const u8* destEnd = newBmp + (width+pitch)*height;
s32 line = 0; s32 line = 0;
while (bmpData - p < size && d < destEnd) while (p < pEnd && d < destEnd)
{ {
if (*p == 0) if (*p == 0)
{ {
++p; ++p; CHECKP(1);
switch(*p) switch(*p)
{ {
@ -68,29 +80,28 @@ void CImageLoaderBMP::decompress8BitRLE(u8*& bmpData, s32 size, s32 width, s32 h
d = newBmp + (line*(width+pitch)); d = newBmp + (line*(width+pitch));
break; break;
case 1: // end of bmp case 1: // end of bmp
delete [] bmpData; goto exit;
bmpData = newBmp;
return;
case 2: case 2:
++p; d +=(u8)*p; // delta ++p; CHECKP(2);
++p; d += ((u8)*p)*(width+pitch); d += (u8)*p; ++p; // delta
++p; d += ((u8)*p)*(width+pitch); ++p;
break; break;
default: default:
{ {
// absolute mode // absolute mode
s32 count = (u8)*p; ++p; s32 count = (u8)*p; ++p;
s32 readAdditional = ((2-(count%2))%2); s32 readAdditional = ((2-(count%2))%2);
s32 i;
for (i=0; i<count; ++i) CHECKP(count); CHECKD(count);
for (s32 i=0; i<count; ++i)
{ {
*d = *p; *d = *p;
++p; ++p;
++d; ++d;
} }
for (i=0; i<readAdditional; ++i) CHECKP(readAdditional);
for (s32 i=0; i<readAdditional; ++i)
++p; ++p;
} }
} }
@ -98,7 +109,9 @@ void CImageLoaderBMP::decompress8BitRLE(u8*& bmpData, s32 size, s32 width, s32 h
else else
{ {
s32 count = (u8)*p; ++p; s32 count = (u8)*p; ++p;
CHECKP(1);
u8 color = *p; ++p; u8 color = *p; ++p;
CHECKD(count);
for (s32 i=0; i<count; ++i) for (s32 i=0; i<count; ++i)
{ {
*d = color; *d = color;
@ -107,26 +120,37 @@ void CImageLoaderBMP::decompress8BitRLE(u8*& bmpData, s32 size, s32 width, s32 h
} }
} }
exit:
delete [] bmpData; delete [] bmpData;
bmpData = newBmp; bmpData = newBmp;
} }
// how many bytes will be touched given the current state of decompress4BitRLE
static inline u32 shiftedCount(s32 count, s32 shift)
{
_IRR_DEBUG_BREAK_IF(count < 0)
u32 ret = count / 2;
if (shift == 0 || count % 2 == 1)
++ret;
return ret;
}
void CImageLoaderBMP::decompress4BitRLE(u8*& bmpData, s32 size, s32 width, s32 height, s32 pitch) const void CImageLoaderBMP::decompress4BitRLE(u8*& bmpData, s32 size, s32 width, s32 height, s32 pitch) const
{ {
s32 lineWidth = (width+1)/2+pitch; const s32 lineWidth = (width+1)/2+pitch;
u8* p = bmpData; u8* p = bmpData;
const u8* pEnd = bmpData + size;
u8* newBmp = new u8[lineWidth*height]; u8* newBmp = new u8[lineWidth*height];
u8* d = newBmp; u8* d = newBmp;
u8* destEnd = newBmp + lineWidth*height; const u8* destEnd = newBmp + lineWidth*height;
s32 line = 0; s32 line = 0;
s32 shift = 4; s32 shift = 4;
while (bmpData - p < size && d < destEnd) while (p < pEnd && d < destEnd)
{ {
if (*p == 0) if (*p == 0)
{ {
++p; ++p; CHECKP(1);
switch(*p) switch(*p)
{ {
@ -137,12 +161,10 @@ void CImageLoaderBMP::decompress4BitRLE(u8*& bmpData, s32 size, s32 width, s32 h
shift = 4; shift = 4;
break; break;
case 1: // end of bmp case 1: // end of bmp
delete [] bmpData; goto exit;
bmpData = newBmp;
return;
case 2: case 2:
{ {
++p; ++p; CHECKP(2);
s32 x = (u8)*p; ++p; s32 x = (u8)*p; ++p;
s32 y = (u8)*p; ++p; s32 y = (u8)*p; ++p;
d += x/2 + y*lineWidth; d += x/2 + y*lineWidth;
@ -155,15 +177,16 @@ void CImageLoaderBMP::decompress4BitRLE(u8*& bmpData, s32 size, s32 width, s32 h
s32 count = (u8)*p; ++p; s32 count = (u8)*p; ++p;
s32 readAdditional = ((2-((count)%2))%2); s32 readAdditional = ((2-((count)%2))%2);
s32 readShift = 4; s32 readShift = 4;
s32 i;
for (i=0; i<count; ++i) CHECKP(shiftedCount(count, readShift));
CHECKD(shiftedCount(count, shift));
for (s32 i=0; i<count; ++i)
{ {
s32 color = (((u8)*p) >> readShift) & 0x0f; s32 color = (((u8)*p) >> readShift) & 0x0f;
readShift -= 4; readShift -= 4;
if (readShift < 0) if (readShift < 0)
{ {
++*p; ++*p; // <- bug?
readShift = 4; readShift = 4;
} }
@ -179,7 +202,8 @@ void CImageLoaderBMP::decompress4BitRLE(u8*& bmpData, s32 size, s32 width, s32 h
} }
for (i=0; i<readAdditional; ++i) CHECKP(readAdditional);
for (s32 i=0; i<readAdditional; ++i)
++p; ++p;
} }
} }
@ -187,10 +211,12 @@ void CImageLoaderBMP::decompress4BitRLE(u8*& bmpData, s32 size, s32 width, s32 h
else else
{ {
s32 count = (u8)*p; ++p; s32 count = (u8)*p; ++p;
CHECKP(1);
s32 color1 = (u8)*p; color1 = color1 & 0x0f; s32 color1 = (u8)*p; color1 = color1 & 0x0f;
s32 color2 = (u8)*p; color2 = (color2 >> 4) & 0x0f; s32 color2 = (u8)*p; color2 = (color2 >> 4) & 0x0f;
++p; ++p;
CHECKD(shiftedCount(count, shift));
for (s32 i=0; i<count; ++i) for (s32 i=0; i<count; ++i)
{ {
u8 mask = 0x0f << shift; u8 mask = 0x0f << shift;
@ -207,11 +233,14 @@ void CImageLoaderBMP::decompress4BitRLE(u8*& bmpData, s32 size, s32 width, s32 h
} }
} }
exit:
delete [] bmpData; delete [] bmpData;
bmpData = newBmp; bmpData = newBmp;
} }
#undef CHECKOFF
#undef CHECKP
#undef CHECKD
//! creates a surface from the file //! creates a surface from the file
IImage* CImageLoaderBMP::loadImage(io::IReadFile* file) const IImage* CImageLoaderBMP::loadImage(io::IReadFile* file) const
@ -262,12 +291,16 @@ IImage* CImageLoaderBMP::loadImage(io::IReadFile* file) const
// read palette // read palette
long pos = file->getPos(); long pos = file->getPos();
constexpr s32 paletteAllocSize = 256;
s32 paletteSize = (header.BitmapDataOffset - pos) / 4; s32 paletteSize = (header.BitmapDataOffset - pos) / 4;
paletteSize = core::clamp(paletteSize, 0, paletteAllocSize);
s32* paletteData = 0; s32* paletteData = 0;
if (paletteSize) if (paletteSize)
{ {
paletteData = new s32[paletteSize]; // always allocate an 8-bit palette to ensure enough space
paletteData = new s32[paletteAllocSize];
memset(paletteData, 0, paletteAllocSize * sizeof(s32));
file->read(paletteData, paletteSize * sizeof(s32)); file->read(paletteData, paletteSize * sizeof(s32));
#ifdef __BIG_ENDIAN__ #ifdef __BIG_ENDIAN__
for (s32 i=0; i<paletteSize; ++i) for (s32 i=0; i<paletteSize; ++i)
@ -286,14 +319,17 @@ IImage* CImageLoaderBMP::loadImage(io::IReadFile* file) const
file->seek(header.BitmapDataOffset); file->seek(header.BitmapDataOffset);
f32 t = (header.Width) * (header.BPP / 8.0f); s32 widthInBytes;
s32 widthInBytes = (s32)t; {
t -= widthInBytes; f32 t = (header.Width) * (header.BPP / 8.0f);
if (t!=0.0f) widthInBytes = (s32)t;
++widthInBytes; t -= widthInBytes;
if (t!=0.0f)
++widthInBytes;
}
s32 lineData = widthInBytes + ((4-(widthInBytes%4)))%4; const s32 lineSize = widthInBytes + ((4-(widthInBytes%4)))%4;
pitch = lineData - widthInBytes; pitch = lineSize - widthInBytes;
u8* bmpData = new u8[header.BitmapDataSize]; u8* bmpData = new u8[header.BitmapDataSize];
file->read(bmpData, header.BitmapDataSize); file->read(bmpData, header.BitmapDataSize);
@ -303,15 +339,24 @@ IImage* CImageLoaderBMP::loadImage(io::IReadFile* file) const
{ {
case 1: // 8 bit rle case 1: // 8 bit rle
decompress8BitRLE(bmpData, header.BitmapDataSize, header.Width, header.Height, pitch); decompress8BitRLE(bmpData, header.BitmapDataSize, header.Width, header.Height, pitch);
header.BitmapDataSize = (header.Width + pitch) * header.Height;
break; break;
case 2: // 4 bit rle case 2: // 4 bit rle
decompress4BitRLE(bmpData, header.BitmapDataSize, header.Width, header.Height, pitch); decompress4BitRLE(bmpData, header.BitmapDataSize, header.Width, header.Height, pitch);
header.BitmapDataSize = ((header.Width+1)/2 + pitch) * header.Height;
break; break;
} }
// create surface if (header.BitmapDataSize < lineSize * header.Height)
{
os::Printer::log("Bitmap data is cut off.", ELL_ERROR);
// no default constructor from packed area! ARM problem! delete [] paletteData;
delete [] bmpData;
return 0;
}
// create surface
core::dimension2d<u32> dim; core::dimension2d<u32> dim;
dim.Width = header.Width; dim.Width = header.Width;
dim.Height = header.Height; dim.Height = header.Height;

View File

@ -31,10 +31,10 @@ u8 *CImageLoaderTGA::loadCompressedImage(io::IReadFile *file, const STGAHeader&
// This was written and sent in by Jon Pry, thank you very much! // This was written and sent in by Jon Pry, thank you very much!
// I only changed the formatting a little bit. // I only changed the formatting a little bit.
s32 bytesPerPixel = header.PixelDepth/8; const u32 bytesPerPixel = header.PixelDepth/8;
s32 imageSize = header.ImageHeight * header.ImageWidth * bytesPerPixel; const u32 imageSize = header.ImageHeight * header.ImageWidth * bytesPerPixel;
u8* data = new u8[imageSize]; u8* data = new u8[imageSize];
s32 currentByte = 0; u32 currentByte = 0;
while(currentByte < imageSize) while(currentByte < imageSize)
{ {
@ -45,8 +45,17 @@ u8 *CImageLoaderTGA::loadCompressedImage(io::IReadFile *file, const STGAHeader&
{ {
chunkheader++; // Add 1 To The Value To Get Total Number Of Raw Pixels chunkheader++; // Add 1 To The Value To Get Total Number Of Raw Pixels
file->read(&data[currentByte], bytesPerPixel * chunkheader); const u32 bytesToRead = bytesPerPixel * chunkheader;
currentByte += bytesPerPixel * chunkheader; if ( currentByte+bytesToRead < imageSize )
{
file->read(&data[currentByte], bytesToRead);
currentByte += bytesToRead;
}
else
{
os::Printer::log("Compressed TGA file RAW chunk tries writing beyond buffer", file->getFileName(), ELL_WARNING);
break;
}
} }
else else
{ {
@ -55,15 +64,27 @@ u8 *CImageLoaderTGA::loadCompressedImage(io::IReadFile *file, const STGAHeader&
// If It's An RLE Header // If It's An RLE Header
chunkheader -= 127; // Subtract 127 To Get Rid Of The ID Bit chunkheader -= 127; // Subtract 127 To Get Rid Of The ID Bit
s32 dataOffset = currentByte; u32 dataOffset = currentByte;
file->read(&data[dataOffset], bytesPerPixel); if ( dataOffset+bytesPerPixel < imageSize )
currentByte += bytesPerPixel;
for(s32 counter = 1; counter < chunkheader; counter++)
{ {
for(s32 elementCounter=0; elementCounter < bytesPerPixel; elementCounter++) file->read(&data[dataOffset], bytesPerPixel);
data[currentByte + elementCounter] = data[dataOffset + elementCounter]; currentByte += bytesPerPixel;
}
else
{
os::Printer::log("Compressed TGA file RLE headertries writing beyond buffer", file->getFileName(), ELL_WARNING);
break;
}
for(u32 counter = 1; counter < chunkheader; counter++)
{
if ( currentByte + bytesPerPixel <= imageSize )
{
for(u32 elementCounter=0; elementCounter < bytesPerPixel; elementCounter++)
{
data[currentByte + elementCounter] = data[dataOffset + elementCounter];
}
}
currentByte += bytesPerPixel; currentByte += bytesPerPixel;
} }
@ -116,8 +137,17 @@ IImage* CImageLoaderTGA::loadImage(io::IReadFile* file) const
if (header.ColorMapType) if (header.ColorMapType)
{ {
// create 32 bit palette // Create 32 bit palette
palette = new u32[ header.ColorMapLength]; const irr::u16 paletteSize = core::max_((u16)256, header.ColorMapLength); // ColorMapLength can lie, but so far we only use palette for 8-bit, so ensure it has 256 entries
palette = new u32[paletteSize];
if( paletteSize > header.ColorMapLength )
{
// To catch images using palette colors with invalid indices
const irr::u32 errorCol = irr::video::SColor(255,255, 0, 205).color; // bright magenta
for ( irr::u16 i = header.ColorMapLength; i< paletteSize; ++i )
palette[i] = errorCol;
}
// read color map // read color map
u8 * colorMap = new u8[header.ColorMapEntrySize/8 * header.ColorMapLength]; u8 * colorMap = new u8[header.ColorMapEntrySize/8 * header.ColorMapLength];
@ -148,7 +178,7 @@ IImage* CImageLoaderTGA::loadImage(io::IReadFile* file) const
header.ImageType == 3 // Uncompressed, black and white images header.ImageType == 3 // Uncompressed, black and white images
) )
{ {
const s32 imageSize = header.ImageHeight * header.ImageWidth * header.PixelDepth/8; const s32 imageSize = header.ImageHeight * header.ImageWidth * (header.PixelDepth/8);
data = new u8[imageSize]; data = new u8[imageSize];
file->read(data, imageSize); file->read(data, imageSize);
} }
@ -183,14 +213,28 @@ IImage* CImageLoaderTGA::loadImage(io::IReadFile* file) const
} }
else else
{ {
image = new CImage(ECF_A1R5G5B5, switch ( header.ColorMapEntrySize )
core::dimension2d<u32>(header.ImageWidth, header.ImageHeight)); {
if (image) case 16:
CColorConverter::convert8BitTo16Bit((u8*)data, image = new CImage(ECF_A1R5G5B5, core::dimension2d<u32>(header.ImageWidth, header.ImageHeight));
(s16*)image->getData(), if ( image )
header.ImageWidth,header.ImageHeight, CColorConverter::convert8BitTo16Bit((u8*)data,
(s32*) palette, 0, (s16*)image->getData(),
(header.ImageDescriptor&0x20)==0); header.ImageWidth,header.ImageHeight,
(s32*) palette, 0,
(header.ImageDescriptor&0x20)==0);
break;
// Note: 24 bit with palette would need a 24 bit palette, too lazy doing that now (textures will prefer 32-bit later anyway)
default:
image = new CImage(ECF_A8R8G8B8, core::dimension2d<u32>(header.ImageWidth, header.ImageHeight));
if ( image )
CColorConverter::convert8BitTo32Bit((u8*)data,
(u8*)image->getData(),
header.ImageWidth,header.ImageHeight,
(u8*) palette, 0,
(header.ImageDescriptor&0x20)==0);
break;
}
} }
} }
break; break;

View File

@ -332,7 +332,7 @@ void CIrrDeviceLinux::setupTopLevelXorgWindow()
Atom NET_WM_PID = XInternAtom(XDisplay, "_NET_WM_PID", false); Atom NET_WM_PID = XInternAtom(XDisplay, "_NET_WM_PID", false);
pid_t pid = getpid(); long pid = static_cast<long>(getpid());
XChangeProperty(XDisplay, XWindow, NET_WM_PID, XChangeProperty(XDisplay, XWindow, NET_WM_PID,
XA_CARDINAL, 32, PropModeReplace, XA_CARDINAL, 32, PropModeReplace,
@ -633,11 +633,6 @@ void CIrrDeviceLinux::createDriver()
os::Printer::log("No WebGL1 support compiled in.", ELL_ERROR); os::Printer::log("No WebGL1 support compiled in.", ELL_ERROR);
#endif #endif
break; break;
case video::DEPRECATED_EDT_DIRECT3D8_NO_LONGER_EXISTS:
case video::EDT_DIRECT3D9:
os::Printer::log("This driver is not available in Linux. Try OpenGL or Software renderer.",
ELL_ERROR);
break;
case video::EDT_NULL: case video::EDT_NULL:
VideoDriver = video::createNullDriver(FileSystem, CreationParams.WindowSize); VideoDriver = video::createNullDriver(FileSystem, CreationParams.WindowSize);
break; break;
@ -987,7 +982,7 @@ bool CIrrDeviceLinux::run()
os::Printer::log("XLookupNone", ELL_INFORMATION); os::Printer::log("XLookupNone", ELL_INFORMATION);
else if ( status == XLookupKeySym ) else if ( status == XLookupKeySym )
// Getting this also when user did not set setlocale(LC_ALL, ""); and using an unknown locale // Getting this also when user did not set setlocale(LC_ALL, ""); and using an unknown locale
// XSupportsLocale doesn't seeem to catch that unfortunately - any other ideas to catch it are welcome. // XSupportsLocale doesn't seem to catch that unfortunately - any other ideas to catch it are welcome.
os::Printer::log("XLookupKeySym", ELL_INFORMATION); os::Printer::log("XLookupKeySym", ELL_INFORMATION);
else if ( status == XBufferOverflow ) else if ( status == XBufferOverflow )
os::Printer::log("XBufferOverflow", ELL_INFORMATION); os::Printer::log("XBufferOverflow", ELL_INFORMATION);
@ -1485,7 +1480,7 @@ void CIrrDeviceLinux::createKeyMap()
KeyMap.push_back(SKeyMap(XK_Next, KEY_NEXT)); KeyMap.push_back(SKeyMap(XK_Next, KEY_NEXT));
KeyMap.push_back(SKeyMap(XK_Page_Down, KEY_NEXT)); KeyMap.push_back(SKeyMap(XK_Page_Down, KEY_NEXT));
KeyMap.push_back(SKeyMap(XK_End, KEY_END)); KeyMap.push_back(SKeyMap(XK_End, KEY_END));
KeyMap.push_back(SKeyMap(XK_Begin, KEY_HOME)); KeyMap.push_back(SKeyMap(XK_Begin, KEY_NUMPAD5));
KeyMap.push_back(SKeyMap(XK_Num_Lock, KEY_NUMLOCK)); KeyMap.push_back(SKeyMap(XK_Num_Lock, KEY_NUMLOCK));
KeyMap.push_back(SKeyMap(XK_KP_Space, KEY_SPACE)); KeyMap.push_back(SKeyMap(XK_KP_Space, KEY_SPACE));
KeyMap.push_back(SKeyMap(XK_KP_Tab, KEY_TAB)); KeyMap.push_back(SKeyMap(XK_KP_Tab, KEY_TAB));
@ -1505,7 +1500,7 @@ void CIrrDeviceLinux::createKeyMap()
KeyMap.push_back(SKeyMap(XK_KP_Next, KEY_NEXT)); KeyMap.push_back(SKeyMap(XK_KP_Next, KEY_NEXT));
KeyMap.push_back(SKeyMap(XK_KP_Page_Down, KEY_NEXT)); KeyMap.push_back(SKeyMap(XK_KP_Page_Down, KEY_NEXT));
KeyMap.push_back(SKeyMap(XK_KP_End, KEY_END)); KeyMap.push_back(SKeyMap(XK_KP_End, KEY_END));
KeyMap.push_back(SKeyMap(XK_KP_Begin, KEY_HOME)); KeyMap.push_back(SKeyMap(XK_KP_Begin, KEY_NUMPAD5));
KeyMap.push_back(SKeyMap(XK_KP_Insert, KEY_INSERT)); KeyMap.push_back(SKeyMap(XK_KP_Insert, KEY_INSERT));
KeyMap.push_back(SKeyMap(XK_KP_Delete, KEY_DELETE)); KeyMap.push_back(SKeyMap(XK_KP_Delete, KEY_DELETE));
KeyMap.push_back(SKeyMap(XK_KP_Equal, 0)); // ??? KeyMap.push_back(SKeyMap(XK_KP_Equal, 0)); // ???
@ -2063,7 +2058,7 @@ Cursor CIrrDeviceLinux::TextureToMonochromeCursor(irr::video::ITexture * tex, co
ZPixmap, // XYBitmap (depth=1), ZPixmap(depth=x) ZPixmap, // XYBitmap (depth=1), ZPixmap(depth=x)
0, 0, sourceRect.getWidth(), sourceRect.getHeight(), 0, 0, sourceRect.getWidth(), sourceRect.getHeight(),
32, // bitmap_pad, 32, // bitmap_pad,
0// bytes_per_line (0 means continuos in memory) 0// bytes_per_line (0 means continuous in memory)
); );
sourceImage->data = new char[sourceImage->height * sourceImage->bytes_per_line]; sourceImage->data = new char[sourceImage->height * sourceImage->bytes_per_line];
XImage * maskImage = XCreateImage(XDisplay, VisualInfo->visual, XImage * maskImage = XCreateImage(XDisplay, VisualInfo->visual,
@ -2256,7 +2251,7 @@ CIrrDeviceLinux::CCursorControl::CCursorControl(CIrrDeviceLinux* dev, bool null)
CIrrDeviceLinux::CCursorControl::~CCursorControl() CIrrDeviceLinux::CCursorControl::~CCursorControl()
{ {
// Do not clearCursors here as the display is already closed // Do not clearCursors here as the display is already closed
// TODO (cutealien): droping cursorcontrol earlier might work, not sure about reason why that's done in stub currently. // TODO (cutealien): dropping cursorcontrol earlier might work, not sure about reason why that's done in stub currently.
} }
#ifdef _IRR_COMPILE_WITH_X11_ #ifdef _IRR_COMPILE_WITH_X11_

View File

@ -22,7 +22,7 @@ namespace irr
class CIrrDeviceMacOSX; class CIrrDeviceMacOSX;
} }
@interface CIrrDelegateOSX : NSObject @interface CIrrDelegateOSX : NSObject <NSApplicationDelegate, NSWindowDelegate>
- (id)initWithDevice:(irr::CIrrDeviceMacOSX*)device; - (id)initWithDevice:(irr::CIrrDeviceMacOSX*)device;
- (void)terminate:(id)sender; - (void)terminate:(id)sender;

View File

@ -564,7 +564,7 @@ CIrrDeviceMacOSX::CIrrDeviceMacOSX(const SIrrlichtCreationParameters& param)
{ {
[[NSAutoreleasePool alloc] init]; [[NSAutoreleasePool alloc] init];
[[NSApplication sharedApplication] activateIgnoringOtherApps:YES]; [[NSApplication sharedApplication] activateIgnoringOtherApps:YES];
[NSApp setDelegate:(id<NSApplicationDelegate>)[[[CIrrDelegateOSX alloc] initWithDevice:this] autorelease]]; [[NSApplication sharedApplication] setDelegate:[[[CIrrDelegateOSX alloc] initWithDevice:this] autorelease]];
// Create menu // Create menu
@ -685,7 +685,7 @@ bool CIrrDeviceMacOSX::createWindow()
{ {
if (Window) if (Window)
{ {
[Window setDelegate:(id<NSWindowDelegate>)[NSApp delegate]]; [Window setDelegate:(CIrrDelegateOSX *)[NSApp delegate]];
[Window setAcceptsMouseMovedEvents:TRUE]; [Window setAcceptsMouseMovedEvents:TRUE];
[Window setIsVisible:TRUE]; [Window setIsVisible:TRUE];
[Window makeKeyAndOrderFront:nil]; [Window makeKeyAndOrderFront:nil];
@ -758,8 +758,6 @@ void CIrrDeviceMacOSX::createDriver()
#endif #endif
break; break;
case video::DEPRECATED_EDT_DIRECT3D8_NO_LONGER_EXISTS:
case video::EDT_DIRECT3D9:
case video::EDT_OGLES1: case video::EDT_OGLES1:
case video::EDT_OGLES2: case video::EDT_OGLES2:
os::Printer::log("This driver is not available in OSX. Try OpenGL or Software renderer.", ELL_ERROR); os::Printer::log("This driver is not available in OSX. Try OpenGL or Software renderer.", ELL_ERROR);

View File

@ -673,7 +673,7 @@ bool CIrrDeviceSDL::run()
{ {
irrevent.EventType = irr::EET_STRING_INPUT_EVENT; irrevent.EventType = irr::EET_STRING_INPUT_EVENT;
irrevent.StringInput.Str = new core::stringw(); irrevent.StringInput.Str = new core::stringw();
irr::core::multibyteToWString(*irrevent.StringInput.Str, SDL_event.text.text); irr::core::utf8ToWString(*irrevent.StringInput.Str, SDL_event.text.text);
postEventFromUser(irrevent); postEventFromUser(irrevent);
delete irrevent.StringInput.Str; delete irrevent.StringInput.Str;
irrevent.StringInput.Str = NULL; irrevent.StringInput.Str = NULL;
@ -928,7 +928,7 @@ void CIrrDeviceSDL::sleep(u32 timeMs, bool pauseTimer)
void CIrrDeviceSDL::setWindowCaption(const wchar_t* text) void CIrrDeviceSDL::setWindowCaption(const wchar_t* text)
{ {
core::stringc textc; core::stringc textc;
core::wStringToMultibyte(textc, text); core::wStringToUTF8(textc, text);
SDL_SetWindowTitle(Window, textc.c_str()); SDL_SetWindowTitle(Window, textc.c_str());
} }

View File

@ -24,7 +24,7 @@ CIrrDeviceStub::CIrrDeviceStub(const SIrrlichtCreationParameters& params)
InputReceivingSceneManager(0), ContextManager(0), InputReceivingSceneManager(0), ContextManager(0),
CreationParams(params), Close(false) CreationParams(params), Close(false)
{ {
Timer = new CTimer(params.UsePerformanceTimer); Timer = new CTimer();
if (os::Printer::Logger) if (os::Printer::Logger)
{ {
os::Printer::Logger->grab(); os::Printer::Logger->grab();

View File

@ -42,10 +42,6 @@ namespace irr
{ {
namespace video namespace video
{ {
#ifdef _IRR_COMPILE_WITH_DIRECT3D_9_
IVideoDriver* createDirectX9Driver(const irr::SIrrlichtCreationParameters& params, io::IFileSystem* io, HWND window);
#endif
#ifdef _IRR_COMPILE_WITH_OPENGL_ #ifdef _IRR_COMPILE_WITH_OPENGL_
IVideoDriver* createOpenGLDriver(const irr::SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager); IVideoDriver* createOpenGLDriver(const irr::SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);
#endif #endif
@ -819,9 +815,6 @@ CIrrDeviceWin32::CIrrDeviceWin32(const SIrrlichtCreationParameters& params)
wcex.lpszClassName = ClassName; wcex.lpszClassName = ClassName;
wcex.hIconSm = 0; wcex.hIconSm = 0;
// if there is an icon, load it
wcex.hIcon = (HICON)LoadImageW(hInstance, L"irrlicht.ico", IMAGE_ICON, 0,0, LR_LOADFROMFILE | LR_DEFAULTSIZE);
RegisterClassExW(&wcex); RegisterClassExW(&wcex);
// calculate client size // calculate client size
@ -951,19 +944,6 @@ void CIrrDeviceWin32::createDriver()
{ {
switch(CreationParams.DriverType) switch(CreationParams.DriverType)
{ {
case video::DEPRECATED_EDT_DIRECT3D8_NO_LONGER_EXISTS:
os::Printer::log("DIRECT3D8 Driver is no longer supported in Irrlicht. Try another one.", ELL_ERROR);
break;
case video::EDT_DIRECT3D9:
#ifdef _IRR_COMPILE_WITH_DIRECT3D_9_
VideoDriver = video::createDirectX9Driver(CreationParams, FileSystem, HWnd);
if (!VideoDriver)
os::Printer::log("Could not create DIRECT3D9 Driver.", ELL_ERROR);
#else
os::Printer::log("DIRECT3D9 Driver was not compiled into this dll. Try another one.", ELL_ERROR);
#endif
break;
case video::EDT_OPENGL: case video::EDT_OPENGL:
#ifdef _IRR_COMPILE_WITH_OPENGL_ #ifdef _IRR_COMPILE_WITH_OPENGL_
switchToFullScreen(); switchToFullScreen();
@ -1044,7 +1024,7 @@ bool CIrrDeviceWin32::run()
//! Pause the current process for the minimum time allowed only to allow other processes to execute //! Pause the current process for the minimum time allowed only to allow other processes to execute
void CIrrDeviceWin32::yield() void CIrrDeviceWin32::yield()
{ {
Sleep(1); Sleep(0);
} }
//! Pause execution and let other processes to run for a specified amount of time. //! Pause execution and let other processes to run for a specified amount of time.

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