minetest
/
irrlicht
mirror of https://github.com/minetest/irrlicht.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Reformat the code, using: 

find -type f |  # list all regular files
  grep -E '\.(h|cpp|mm)$' |  # filter for source files
  grep -v '/mt_' |  # filter out generated files
  grep -v '/vendor/' | # and vendored GL
  grep -v '/test/image_loader_test.cpp' |  # and this file (has giant literals arrays)
  xargs -n 1 -P $(nproc) clang-format -i  # reformat everything

Co-authored-by: numzero <numzer0@yandex.ru>
This commit is contained in:
Desour 2024-03-20 19:35:52 +01:00
parent eb4dec46c2
commit 2bf1d12353
292 changed files with 37376 additions and 42421 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
examples/AutomatedTest/main.cpp
View File

@ -28,14 +28,14 @@ static video::E_DRIVER_TYPE chooseDriver(core::stringc arg_)
static inline void check(bool ok, const char *msg) static inline void check(bool ok, const char *msg)
{ {
if (!ok) if (!ok) {
{
test_fail++; test_fail++;
device->getLogger()->log((core::stringc("FAILED TEST: ") + msg).c_str(), ELL_ERROR); device->getLogger()->log((core::stringc("FAILED TEST: ") + msg).c_str(), ELL_ERROR);
} }
} }
void run_unit_tests() { void run_unit_tests()
{
std::cout << "Running unit tests:" << std::endl; std::cout << "Running unit tests:" << std::endl;
try { try {
test_irr_array(); test_irr_array();
@ -72,35 +72,33 @@ int main(int argc, char *argv[])
device->setWindowCaption(L"Hello World!"); device->setWindowCaption(L"Hello World!");
device->setResizable(true); device->setResizable(true);
video::IVideoDriver* driver = device->getVideoDriver(); video::IVideoDriver *driver = device->getVideoDriver();
scene::ISceneManager* smgr = device->getSceneManager(); scene::ISceneManager *smgr = device->getSceneManager();
gui::IGUIEnvironment* guienv = device->getGUIEnvironment(); gui::IGUIEnvironment *guienv = device->getGUIEnvironment();
guienv->addStaticText(L"sample text", core::rect<s32>(10,10,110,22), false); guienv->addStaticText(L"sample text", core::rect<s32>(10, 10, 110, 22), false);
gui::IGUIButton* button = guienv->addButton( gui::IGUIButton *button = guienv->addButton(
core::rect<s32>(10,30,110,30 + 32), 0, -1, L"sample button", core::rect<s32>(10, 30, 110, 30 + 32), 0, -1, L"sample button",
L"sample tooltip"); L"sample tooltip");
gui::IGUIEditBox* editbox = guienv->addEditBox(L"", gui::IGUIEditBox *editbox = guienv->addEditBox(L"",
core::rect<s32>(10,70,60,70 + 16)); core::rect<s32>(10, 70, 60, 70 + 16));
const io::path mediaPath = getExampleMediaPath(); const io::path mediaPath = getExampleMediaPath();
auto mesh_file = device->getFileSystem()->createAndOpenFile(mediaPath + "coolguy_opt.x"); auto mesh_file = device->getFileSystem()->createAndOpenFile(mediaPath + "coolguy_opt.x");
check(mesh_file, "mesh file loading"); check(mesh_file, "mesh file loading");
scene::IAnimatedMesh* mesh = smgr->getMesh(mesh_file); scene::IAnimatedMesh *mesh = smgr->getMesh(mesh_file);
check(mesh, "mesh loading"); check(mesh, "mesh loading");
if (mesh_file) if (mesh_file)
mesh_file->drop(); mesh_file->drop();
if (mesh) if (mesh) {
{ video::ITexture *tex = driver->getTexture(mediaPath + "cooltexture.png");
video::ITexture* tex = driver->getTexture(mediaPath + "cooltexture.png");
check(tex, "texture loading"); check(tex, "texture loading");
scene::IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode(mesh); scene::IAnimatedMeshSceneNode *node = smgr->addAnimatedMeshSceneNode(mesh);
if (node) if (node) {
{ node->forEachMaterial([tex](video::SMaterial &mat) {
node->forEachMaterial([tex] (video::SMaterial &mat) {
mat.Lighting = false; mat.Lighting = false;
mat.setTexture(0, tex); mat.setTexture(0, tex);
}); });
@ -109,16 +107,14 @@ int main(int argc, char *argv[])
} }
} }
smgr->addCameraSceneNode(0, core::vector3df(0,4,5), core::vector3df(0,2,0)); smgr->addCameraSceneNode(0, core::vector3df(0, 4, 5), core::vector3df(0, 2, 0));
s32 n = 0; s32 n = 0;
SEvent event; SEvent event;
device->getTimer()->start(); device->getTimer()->start();
while (device->run()) while (device->run()) {
{ if (device->getTimer()->getTime() >= 1000) {
if (device->getTimer()->getTime() >= 1000)
{
device->getTimer()->setTime(0); device->getTimer()->setTime(0);
++n; ++n;
if (n == 1) // Tooltip display if (n == 1) // Tooltip display
@ -129,8 +125,7 @@ int main(int argc, char *argv[])
event.MouseInput.X = button->getAbsolutePosition().getCenter().X; event.MouseInput.X = button->getAbsolutePosition().getCenter().X;
event.MouseInput.Y = button->getAbsolutePosition().getCenter().Y; event.MouseInput.Y = button->getAbsolutePosition().getCenter().Y;
device->postEventFromUser(event); device->postEventFromUser(event);
} } else if (n == 2) // Text input focus
else if (n == 2) // Text input focus
guienv->setFocus(editbox); guienv->setFocus(editbox);
else if (n == 3) // Keypress for Text input else if (n == 3) // Keypress for Text input
{ {
@ -142,13 +137,12 @@ int main(int argc, char *argv[])
device->postEventFromUser(event); device->postEventFromUser(event);
event.KeyInput.PressedDown = false; event.KeyInput.PressedDown = false;
device->postEventFromUser(event); device->postEventFromUser(event);
} } else
else
device->closeDevice(); device->closeDevice();
} }
driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH, driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH,
video::SColor(255,100,100,150)); video::SColor(255, 100, 100, 150));
smgr->drawAll(); smgr->drawAll();
guienv->drawAll(); guienv->drawAll();
driver->endScene(); driver->endScene();

21
examples/AutomatedTest/test_array.cpp
View File

@ -4,13 +4,14 @@
using namespace irr; using namespace irr;
using core::array; using core::array;
static void test_basics() { static void test_basics()
{
array<int> v; array<int> v;
v.push_back(1); // 1 v.push_back(1); // 1
v.push_front(2); // 2, 1 v.push_front(2); // 2, 1
v.insert(4, 0); // 4, 2, 1 v.insert(4, 0); // 4, 2, 1
v.insert(3, 1); // 4, 3, 2, 1 v.insert(3, 1); // 4, 3, 2, 1
v.insert(0, 4); // 4, 3, 2, 1, 0 v.insert(0, 4); // 4, 3, 2, 1, 0
UASSERTEQ(v.size(), 5); UASSERTEQ(v.size(), 5);
UASSERTEQ(v[0], 4); UASSERTEQ(v[0], 4);
UASSERTEQ(v[1], 3); UASSERTEQ(v[1], 3);
@ -57,7 +58,8 @@ static void test_basics() {
UASSERTEQ(v.size(), 2); UASSERTEQ(v.size(), 2);
} }
static void test_linear_searches() { static void test_linear_searches()
{
// Populate the array with 0, 1, 2, ..., 100, 100, 99, 98, 97, ..., 0 // Populate the array with 0, 1, 2, ..., 100, 100, 99, 98, 97, ..., 0
array<int> arr; array<int> arr;
for (int i = 0; i <= 100; i++) for (int i = 0; i <= 100; i++)
@ -75,14 +77,15 @@ static void test_linear_searches() {
} }
} }
static void test_binary_searches() { static void test_binary_searches()
const auto& values = { 3, 5, 1, 2, 5, 10, 19, 9, 7, 1, 2, 5, 8, 15 }; {
const auto &values = {3, 5, 1, 2, 5, 10, 19, 9, 7, 1, 2, 5, 8, 15};
array<int> arr; array<int> arr;
for (int value : values) { for (int value : values) {
arr.push_back(value); arr.push_back(value);
} }
// Test the const form first, it uses a linear search without sorting // Test the const form first, it uses a linear search without sorting
const array<int> & carr = arr; const array<int> &carr = arr;
UASSERTEQ(carr.binary_search(20), -1); UASSERTEQ(carr.binary_search(20), -1);
UASSERTEQ(carr.binary_search(0), -1); UASSERTEQ(carr.binary_search(0), -1);
UASSERTEQ(carr.binary_search(1), 2); UASSERTEQ(carr.binary_search(1), 2);

41
examples/AutomatedTest/test_helper.h
View File

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

10
examples/AutomatedTest/test_string.cpp
View File

@ -38,7 +38,7 @@ static void test_basics()
UASSERTSTR(s, "abcdef"); UASSERTSTR(s, "abcdef");
s = L"abcdef"; s = L"abcdef";
UASSERTSTR(s, "abcdef"); UASSERTSTR(s, "abcdef");
s = static_cast<const char*>(nullptr); s = static_cast<const char *>(nullptr);
UASSERTSTR(s, ""); UASSERTSTR(s, "");
// operator+ // operator+
s = s + stringc("foo"); s = s + stringc("foo");
@ -163,7 +163,7 @@ static void test_methods()
UASSERTSTR(res[0], "a"); UASSERTSTR(res[0], "a");
UASSERTSTR(res[2], ""); UASSERTSTR(res[2], "");
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
UASSERTSTR(res[2*i+1], ","); UASSERTSTR(res[2 * i + 1], ",");
} }
static void test_conv() static void test_conv()
@ -180,9 +180,9 @@ static void test_conv()
wStringToUTF8(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 // locale-dependent

502
include/CMeshBuffer.h
View File

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

37
include/ECullingTypes.h
View File

@ -11,26 +11,25 @@ namespace irr
namespace scene namespace scene
{ {
//! An enumeration for all types of automatic culling for built-in scene nodes //! An enumeration for all types of automatic culling for built-in scene nodes
enum E_CULLING_TYPE enum E_CULLING_TYPE
{ {
EAC_OFF = 0, EAC_OFF = 0,
EAC_BOX = 1, EAC_BOX = 1,
EAC_FRUSTUM_BOX = 2, EAC_FRUSTUM_BOX = 2,
EAC_FRUSTUM_SPHERE = 4, EAC_FRUSTUM_SPHERE = 4,
EAC_OCC_QUERY = 8 EAC_OCC_QUERY = 8
}; };
//! Names for culling type //! Names for culling type
const c8* const AutomaticCullingNames[] = const c8 *const AutomaticCullingNames[] =
{ {
"false", "false",
"box", // camera box against node box "box", // camera box against node box
"frustum_box", // camera frustum against node box "frustum_box", // camera frustum against node box
"frustum_sphere", // camera frustum against node sphere "frustum_sphere", // camera frustum against node sphere
"occ_query", // occlusion query "occ_query", // occlusion query
0 0};
};
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

41
include/EDebugSceneTypes.h
View File

@ -9,34 +9,33 @@ namespace irr
namespace scene namespace scene
{ {
//! An enumeration for all types of debug data for built-in scene nodes (flags) //! An enumeration for all types of debug data for built-in scene nodes (flags)
enum E_DEBUG_SCENE_TYPE enum E_DEBUG_SCENE_TYPE
{ {
//! No Debug Data ( Default ) //! No Debug Data ( Default )
EDS_OFF = 0, EDS_OFF = 0,
//! Show Bounding Boxes of SceneNode //! Show Bounding Boxes of SceneNode
EDS_BBOX = 1, EDS_BBOX = 1,
//! Show Vertex Normals //! Show Vertex Normals
EDS_NORMALS = 2, EDS_NORMALS = 2,
//! Shows Skeleton/Tags //! Shows Skeleton/Tags
EDS_SKELETON = 4, EDS_SKELETON = 4,
//! Overlays Mesh Wireframe //! Overlays Mesh Wireframe
EDS_MESH_WIRE_OVERLAY = 8, EDS_MESH_WIRE_OVERLAY = 8,
//! Show Bounding Boxes of all MeshBuffers //! Show Bounding Boxes of all MeshBuffers
EDS_BBOX_BUFFERS = 32, EDS_BBOX_BUFFERS = 32,
//! EDS_BBOX | EDS_BBOX_BUFFERS //! EDS_BBOX | EDS_BBOX_BUFFERS
EDS_BBOX_ALL = EDS_BBOX | EDS_BBOX_BUFFERS, EDS_BBOX_ALL = EDS_BBOX | EDS_BBOX_BUFFERS,
//! Show all debug infos
EDS_FULL = 0xffffffff
};
//! Show all debug infos
EDS_FULL = 0xffffffff
};
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

58
include/EDeviceTypes.h
View File

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

168
include/EDriverFeatures.h
View File

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

44
include/EDriverTypes.h
View File

@ -11,34 +11,34 @@ namespace irr
namespace video namespace video
{ {
//! An enum for all types of drivers the Irrlicht Engine supports. //! An enum for all types of drivers the Irrlicht Engine supports.
enum E_DRIVER_TYPE enum E_DRIVER_TYPE
{ {
//! Null driver, useful for applications to run the engine without visualization. //! Null driver, useful for applications to run the engine without visualization.
/** The null device is able to load textures, but does not /** The null device is able to load textures, but does not
render and display any graphics. */ render and display any graphics. */
EDT_NULL, EDT_NULL,
//! 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. */
EDT_OPENGL, EDT_OPENGL,
//! OpenGL-ES 1.x driver, for embedded and mobile systems //! OpenGL-ES 1.x driver, for embedded and mobile systems
EDT_OGLES1, EDT_OGLES1,
//! OpenGL-ES 2.x driver, for embedded and mobile systems //! OpenGL-ES 2.x driver, for embedded and mobile systems
/** Supports shaders etc. */ /** Supports shaders etc. */
EDT_OGLES2, EDT_OGLES2,
//! WebGL1 friendly subset of OpenGL-ES 2.x driver for Emscripten //! WebGL1 friendly subset of OpenGL-ES 2.x driver for Emscripten
EDT_WEBGL1, EDT_WEBGL1,
EDT_OPENGL3, EDT_OPENGL3,
//! No driver, just for counting the elements //! No driver, just for counting the elements
EDT_COUNT EDT_COUNT
}; };
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

17
include/EGUIAlignment.h
View File

@ -13,7 +13,7 @@ namespace gui
enum EGUI_ALIGNMENT enum EGUI_ALIGNMENT
{ {
//! Aligned to parent's top or left side (default) //! Aligned to parent's top or left side (default)
EGUIA_UPPERLEFT=0, EGUIA_UPPERLEFT = 0,
//! Aligned to parent's bottom or right side //! Aligned to parent's bottom or right side
EGUIA_LOWERRIGHT, EGUIA_LOWERRIGHT,
//! Aligned to the center of parent //! Aligned to the center of parent
@ -23,14 +23,13 @@ enum EGUI_ALIGNMENT
}; };
//! Names for alignments //! Names for alignments
const c8* const GUIAlignmentNames[] = const c8 *const GUIAlignmentNames[] =
{ {
"upperLeft", "upperLeft",
"lowerRight", "lowerRight",
"center", "center",
"scale", "scale",
0 0};
};
} // namespace gui } // namespace gui
} // namespace irr } // namespace irr

59
include/EGUIElementTypes.h
View File

@ -99,36 +99,35 @@ enum EGUI_ELEMENT_TYPE
}; };
//! Names for built-in element types //! Names for built-in element types
const c8* const GUIElementTypeNames[] = const c8 *const GUIElementTypeNames[] =
{ {
"button", "button",
"checkBox", "checkBox",
"comboBox", "comboBox",
"contextMenu", "contextMenu",
"menu", "menu",
"editBox", "editBox",
"fileOpenDialog", "fileOpenDialog",
"colorSelectDialog", "colorSelectDialog",
"inOutFader", "inOutFader",
"image", "image",
"listBox", "listBox",
"meshViewer", "meshViewer",
"messageBox", "messageBox",
"modalScreen", "modalScreen",
"scrollBar", "scrollBar",
"spinBox", "spinBox",
"staticText", "staticText",
"tab", "tab",
"tabControl", "tabControl",
"table", "table",
"toolBar", "toolBar",
"treeview", "treeview",
"window", "window",
"element", "element",
"root", "root",
"profiler", "profiler",
0 0};
};
} // end namespace gui } // end namespace gui
} // end namespace irr } // end namespace irr

44
include/EHardwareBufferFlags.h
View File

@ -9,32 +9,32 @@ namespace irr
namespace scene namespace scene
{ {
enum E_HARDWARE_MAPPING enum E_HARDWARE_MAPPING
{ {
//! Don't store on the hardware //! Don't store on the hardware
EHM_NEVER=0, EHM_NEVER = 0,
//! Rarely changed, usually stored completely on the hardware //! Rarely changed, usually stored completely on the hardware
EHM_STATIC, EHM_STATIC,
//! Sometimes changed, driver optimized placement //! Sometimes changed, driver optimized placement
EHM_DYNAMIC, EHM_DYNAMIC,
//! Always changed, cache optimizing on the GPU //! Always changed, cache optimizing on the GPU
EHM_STREAM EHM_STREAM
}; };
enum E_BUFFER_TYPE enum E_BUFFER_TYPE
{ {
//! Does not change anything //! Does not change anything
EBT_NONE=0, EBT_NONE = 0,
//! Change the vertex mapping //! Change the vertex mapping
EBT_VERTEX, EBT_VERTEX,
//! Change the index mapping //! Change the index mapping
EBT_INDEX, EBT_INDEX,
//! Change both vertex and index mapping to the same value //! Change both vertex and index mapping to the same value
EBT_VERTEX_AND_INDEX EBT_VERTEX_AND_INDEX
}; };
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

96
include/EMaterialProps.h
View File

@ -9,74 +9,74 @@ namespace irr
namespace video namespace video
{ {
//! Material properties //! Material properties
enum E_MATERIAL_PROP enum E_MATERIAL_PROP
{ {
//! Corresponds to SMaterial::Wireframe. //! Corresponds to SMaterial::Wireframe.
EMP_WIREFRAME = 0x1, EMP_WIREFRAME = 0x1,
//! Corresponds to SMaterial::PointCloud. //! Corresponds to SMaterial::PointCloud.
EMP_POINTCLOUD = 0x2, EMP_POINTCLOUD = 0x2,
//! Corresponds to SMaterial::GouraudShading. //! Corresponds to SMaterial::GouraudShading.
EMP_GOURAUD_SHADING = 0x4, EMP_GOURAUD_SHADING = 0x4,
//! Corresponds to SMaterial::Lighting. //! Corresponds to SMaterial::Lighting.
EMP_LIGHTING = 0x8, EMP_LIGHTING = 0x8,
//! Corresponds to SMaterial::ZBuffer. //! Corresponds to SMaterial::ZBuffer.
EMP_ZBUFFER = 0x10, EMP_ZBUFFER = 0x10,
//! Corresponds to SMaterial::ZWriteEnable. //! Corresponds to SMaterial::ZWriteEnable.
EMP_ZWRITE_ENABLE = 0x20, EMP_ZWRITE_ENABLE = 0x20,
//! Corresponds to SMaterial::BackfaceCulling. //! Corresponds to SMaterial::BackfaceCulling.
EMP_BACK_FACE_CULLING = 0x40, EMP_BACK_FACE_CULLING = 0x40,
//! Corresponds to SMaterial::FrontfaceCulling. //! Corresponds to SMaterial::FrontfaceCulling.
EMP_FRONT_FACE_CULLING = 0x80, EMP_FRONT_FACE_CULLING = 0x80,
//! Corresponds to SMaterialLayer::MinFilter. //! Corresponds to SMaterialLayer::MinFilter.
EMP_MIN_FILTER = 0x100, EMP_MIN_FILTER = 0x100,
//! Corresponds to SMaterialLayer::MagFilter. //! Corresponds to SMaterialLayer::MagFilter.
EMP_MAG_FILTER = 0x200, EMP_MAG_FILTER = 0x200,
//! Corresponds to SMaterialLayer::AnisotropicFilter. //! Corresponds to SMaterialLayer::AnisotropicFilter.
EMP_ANISOTROPIC_FILTER = 0x400, EMP_ANISOTROPIC_FILTER = 0x400,
//! Corresponds to SMaterial::FogEnable. //! Corresponds to SMaterial::FogEnable.
EMP_FOG_ENABLE = 0x800, EMP_FOG_ENABLE = 0x800,
//! Corresponds to SMaterial::NormalizeNormals. //! Corresponds to SMaterial::NormalizeNormals.
EMP_NORMALIZE_NORMALS = 0x1000, EMP_NORMALIZE_NORMALS = 0x1000,
//! Corresponds to SMaterialLayer::TextureWrapU, TextureWrapV and //! Corresponds to SMaterialLayer::TextureWrapU, TextureWrapV and
//! TextureWrapW. //! TextureWrapW.
EMP_TEXTURE_WRAP = 0x2000, EMP_TEXTURE_WRAP = 0x2000,
//! Corresponds to SMaterial::AntiAliasing. //! Corresponds to SMaterial::AntiAliasing.
EMP_ANTI_ALIASING = 0x4000, EMP_ANTI_ALIASING = 0x4000,
//! Corresponds to SMaterial::ColorMask. //! Corresponds to SMaterial::ColorMask.
EMP_COLOR_MASK = 0x8000, EMP_COLOR_MASK = 0x8000,
//! Corresponds to SMaterial::ColorMaterial. //! Corresponds to SMaterial::ColorMaterial.
EMP_COLOR_MATERIAL = 0x10000, EMP_COLOR_MATERIAL = 0x10000,
//! Corresponds to SMaterial::UseMipMaps. //! Corresponds to SMaterial::UseMipMaps.
EMP_USE_MIP_MAPS = 0x20000, EMP_USE_MIP_MAPS = 0x20000,
//! Corresponds to SMaterial::BlendOperation. //! Corresponds to SMaterial::BlendOperation.
EMP_BLEND_OPERATION = 0x40000, EMP_BLEND_OPERATION = 0x40000,
//! Corresponds to SMaterial::PolygonOffsetFactor, PolygonOffsetDirection, //! Corresponds to SMaterial::PolygonOffsetFactor, PolygonOffsetDirection,
//! PolygonOffsetDepthBias and PolygonOffsetSlopeScale. //! PolygonOffsetDepthBias and PolygonOffsetSlopeScale.
EMP_POLYGON_OFFSET = 0x80000, EMP_POLYGON_OFFSET = 0x80000,
//! Corresponds to SMaterial::BlendFactor. //! Corresponds to SMaterial::BlendFactor.
EMP_BLEND_FACTOR = 0x100000, EMP_BLEND_FACTOR = 0x100000,
}; };
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

103
include/EMaterialTypes.h
View File

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

44
include/EPrimitiveTypes.h
View File

@ -9,35 +9,35 @@ namespace irr
namespace scene namespace scene
{ {
//! Enumeration for all primitive types there are. //! Enumeration for all primitive types there are.
enum E_PRIMITIVE_TYPE enum E_PRIMITIVE_TYPE
{ {
//! All vertices are non-connected points. //! All vertices are non-connected points.
EPT_POINTS=0, EPT_POINTS = 0,
//! All vertices form a single connected line. //! All vertices form a single connected line.
EPT_LINE_STRIP, EPT_LINE_STRIP,
//! Just as LINE_STRIP, but the last and the first vertex is also connected. //! Just as LINE_STRIP, but the last and the first vertex is also connected.
EPT_LINE_LOOP, EPT_LINE_LOOP,
//! Every two vertices are connected creating n/2 lines. //! Every two vertices are connected creating n/2 lines.
EPT_LINES, EPT_LINES,
//! After the first two vertices each vertex defines a new triangle. //! After the first two vertices each vertex defines a new triangle.
//! Always the two last and the new one form a new triangle. //! Always the two last and the new one form a new triangle.
EPT_TRIANGLE_STRIP, EPT_TRIANGLE_STRIP,
//! After the first two vertices each vertex defines a new triangle. //! After the first two vertices each vertex defines a new triangle.
//! All around the common first vertex. //! All around the common first vertex.
EPT_TRIANGLE_FAN, EPT_TRIANGLE_FAN,
//! Explicitly set all vertices for each triangle. //! Explicitly set all vertices for each triangle.
EPT_TRIANGLES, EPT_TRIANGLES,
//! 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
}; };
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

24
include/EReadFileType.h
View File

@ -11,20 +11,20 @@ namespace irr
namespace io namespace io
{ {
//! An enumeration for different class types implementing IReadFile //! An enumeration for different class types implementing IReadFile
enum EREAD_FILE_TYPE enum EREAD_FILE_TYPE
{ {
//! CReadFile //! CReadFile
ERFT_READ_FILE = MAKE_IRR_ID('r','e','a','d'), ERFT_READ_FILE = MAKE_IRR_ID('r', 'e', 'a', 'd'),
//! CMemoryReadFile //! CMemoryReadFile
ERFT_MEMORY_READ_FILE = MAKE_IRR_ID('r','m','e','m'), ERFT_MEMORY_READ_FILE = MAKE_IRR_ID('r', 'm', 'e', 'm'),
//! CLimitReadFile //! CLimitReadFile
ERFT_LIMIT_READ_FILE = MAKE_IRR_ID('r','l','i','m'), ERFT_LIMIT_READ_FILE = MAKE_IRR_ID('r', 'l', 'i', 'm'),
//! Unknown type //! Unknown type
EFIT_UNKNOWN = MAKE_IRR_ID('u','n','k','n') EFIT_UNKNOWN = MAKE_IRR_ID('u', 'n', 'k', 'n')
}; };
} // end namespace io } // end namespace io
} // end namespace irr } // end namespace irr

52
include/ESceneNodeTypes.h
View File

@ -11,41 +11,39 @@ namespace irr
namespace scene namespace scene
{ {
//! An enumeration for all types of built-in scene nodes //! An enumeration for all types of built-in scene nodes
/** A scene node type is represented by a four character code /** A scene node type is represented by a four character code
such as 'cube' or 'mesh' instead of simple numbers, to avoid such as 'cube' or 'mesh' instead of simple numbers, to avoid
name clashes with external scene nodes.*/ name clashes with external scene nodes.*/
enum ESCENE_NODE_TYPE enum ESCENE_NODE_TYPE
{ {
//! of type CSceneManager (note that ISceneManager is not(!) an ISceneNode) //! of type CSceneManager (note that ISceneManager is not(!) an ISceneNode)
ESNT_SCENE_MANAGER = MAKE_IRR_ID('s','m','n','g'), ESNT_SCENE_MANAGER = MAKE_IRR_ID('s', 'm', 'n', 'g'),
//! Mesh Scene Node //! Mesh Scene Node
ESNT_MESH = MAKE_IRR_ID('m','e','s','h'), ESNT_MESH = MAKE_IRR_ID('m', 'e', 's', 'h'),
//! Empty Scene Node //! Empty Scene Node
ESNT_EMPTY = MAKE_IRR_ID('e','m','t','y'), ESNT_EMPTY = MAKE_IRR_ID('e', 'm', 't', 'y'),
//! Dummy Transformation Scene Node //! Dummy Transformation Scene Node
ESNT_DUMMY_TRANSFORMATION = MAKE_IRR_ID('d','m','m','y'), ESNT_DUMMY_TRANSFORMATION = MAKE_IRR_ID('d', 'm', 'm', 'y'),
//! Camera Scene Node //! Camera Scene Node
ESNT_CAMERA = MAKE_IRR_ID('c','a','m','_'), ESNT_CAMERA = MAKE_IRR_ID('c', 'a', 'm', '_'),
//! Billboard Scene Node //! Billboard Scene Node
ESNT_BILLBOARD = MAKE_IRR_ID('b','i','l','l'), ESNT_BILLBOARD = MAKE_IRR_ID('b', 'i', 'l', 'l'),
//! Animated Mesh Scene Node //! Animated Mesh Scene Node
ESNT_ANIMATED_MESH = MAKE_IRR_ID('a','m','s','h'), ESNT_ANIMATED_MESH = MAKE_IRR_ID('a', 'm', 's', 'h'),
//! Unknown scene node
ESNT_UNKNOWN = MAKE_IRR_ID('u','n','k','n'),
//! Will match with any scene node when checking types
ESNT_ANY = MAKE_IRR_ID('a','n','y','_')
};
//! Unknown scene node
ESNT_UNKNOWN = MAKE_IRR_ID('u', 'n', 'k', 'n'),
//! Will match with any scene node when checking types
ESNT_ANY = MAKE_IRR_ID('a', 'n', 'y', '_')
};
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

51
include/EShaderTypes.h
View File

@ -23,15 +23,15 @@ enum E_VERTEX_SHADER_TYPE
}; };
//! Names for all vertex shader types, each entry corresponds to a E_VERTEX_SHADER_TYPE entry. //! Names for all vertex shader types, each entry corresponds to a E_VERTEX_SHADER_TYPE entry.
const c8* const VERTEX_SHADER_TYPE_NAMES[] = { const c8 *const VERTEX_SHADER_TYPE_NAMES[] = {
"vs_1_1", "vs_1_1",
"vs_2_0", "vs_2_0",
"vs_2_a", "vs_2_a",
"vs_3_0", "vs_3_0",
"vs_4_0", "vs_4_0",
"vs_4_1", "vs_4_1",
"vs_5_0", "vs_5_0",
0 }; 0};
//! Compile target enumeration for the addHighLevelShaderMaterial() method. //! Compile target enumeration for the addHighLevelShaderMaterial() method.
enum E_PIXEL_SHADER_TYPE enum E_PIXEL_SHADER_TYPE
@ -53,19 +53,19 @@ enum E_PIXEL_SHADER_TYPE
}; };
//! Names for all pixel shader types, each entry corresponds to a E_PIXEL_SHADER_TYPE entry. //! Names for all pixel shader types, each entry corresponds to a E_PIXEL_SHADER_TYPE entry.
const c8* const PIXEL_SHADER_TYPE_NAMES[] = { const c8 *const PIXEL_SHADER_TYPE_NAMES[] = {
"ps_1_1", "ps_1_1",
"ps_1_2", "ps_1_2",
"ps_1_3", "ps_1_3",
"ps_1_4", "ps_1_4",
"ps_2_0", "ps_2_0",
"ps_2_a", "ps_2_a",
"ps_2_b", "ps_2_b",
"ps_3_0", "ps_3_0",
"ps_4_0", "ps_4_0",
"ps_4_1", "ps_4_1",
"ps_5_0", "ps_5_0",
0 }; 0};
//! Enum for supported geometry shader types //! Enum for supported geometry shader types
enum E_GEOMETRY_SHADER_TYPE enum E_GEOMETRY_SHADER_TYPE
@ -77,10 +77,9 @@ enum E_GEOMETRY_SHADER_TYPE
}; };
//! String names for supported geometry shader types //! String names for supported geometry shader types
const c8* const GEOMETRY_SHADER_TYPE_NAMES[] = { const c8 *const GEOMETRY_SHADER_TYPE_NAMES[] = {
"gs_4_0", "gs_4_0",
0 }; 0};
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

21
include/EVertexAttributes.h
View File

@ -19,17 +19,16 @@ enum E_VERTEX_ATTRIBUTES
}; };
//! Array holding the built in vertex attribute names //! Array holding the built in vertex attribute names
const char* const sBuiltInVertexAttributeNames[] = const char *const sBuiltInVertexAttributeNames[] =
{ {
"inVertexPosition", "inVertexPosition",
"inVertexNormal", "inVertexNormal",
"inVertexColor", "inVertexColor",
"inTexCoord0", "inTexCoord0",
"inTexCoord1", "inTexCoord1",
"inVertexTangent", "inVertexTangent",
"inVertexBinormal", "inVertexBinormal",
0 0};
};
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

105
include/IAnimatedMesh.h
View File

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

256
include/IAnimatedMeshSceneNode.h
View File

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

32
include/IAttributes.h
View File

@ -14,7 +14,7 @@ namespace irr
{ {
namespace video namespace video
{ {
class ITexture; class ITexture;
} // end namespace video } // end namespace video
namespace io namespace io
{ {
@ -23,32 +23,30 @@ namespace io
class IAttributes : public virtual IReferenceCounted class IAttributes : public virtual IReferenceCounted
{ {
public: public:
//! Returns amount of attributes in this collection of attributes. //! Returns amount of attributes in this collection of attributes.
virtual u32 getAttributeCount() const = 0; virtual u32 getAttributeCount() const = 0;
//! Returns attribute name by index. //! Returns attribute name by index.
//! \param index: Index value, must be between 0 and getAttributeCount()-1. //! \param index: Index value, must be between 0 and getAttributeCount()-1.
virtual const c8* getAttributeName(s32 index) const = 0; virtual const c8 *getAttributeName(s32 index) const = 0;
//! Returns the type of an attribute //! Returns the type of an attribute
//! \param attributeName: Name for the attribute //! \param attributeName: Name for the attribute
virtual E_ATTRIBUTE_TYPE getAttributeType(const c8* attributeName) const = 0; virtual E_ATTRIBUTE_TYPE getAttributeType(const c8 *attributeName) const = 0;
//! Returns attribute type by index. //! Returns attribute type by index.
//! \param index: Index value, must be between 0 and getAttributeCount()-1. //! \param index: Index value, must be between 0 and getAttributeCount()-1.
virtual E_ATTRIBUTE_TYPE getAttributeType(s32 index) const = 0; virtual E_ATTRIBUTE_TYPE getAttributeType(s32 index) const = 0;
//! Returns if an attribute with a name exists //! Returns if an attribute with a name exists
virtual bool existsAttribute(const c8* attributeName) const = 0; virtual bool existsAttribute(const c8 *attributeName) const = 0;
//! Returns attribute index from name, -1 if not found //! Returns attribute index from name, -1 if not found
virtual s32 findAttribute(const c8* attributeName) const = 0; virtual s32 findAttribute(const c8 *attributeName) const = 0;
//! Removes all attributes //! Removes all attributes
virtual void clear() = 0; virtual void clear() = 0;
/* /*
Integer Attribute Integer Attribute
@ -56,16 +54,16 @@ public:
*/ */
//! Adds an attribute as integer //! Adds an attribute as integer
virtual void addInt(const c8* attributeName, s32 value) = 0; virtual void addInt(const c8 *attributeName, s32 value) = 0;
//! Sets an attribute as integer value //! Sets an attribute as integer value
virtual void setAttribute(const c8* attributeName, s32 value) = 0; virtual void setAttribute(const c8 *attributeName, s32 value) = 0;
//! Gets an attribute as integer value //! Gets an attribute as integer value
//! \param attributeName: Name of the attribute to get. //! \param attributeName: Name of the attribute to get.
//! \param defaultNotFound Value returned when attributeName was not found //! \param defaultNotFound Value returned when attributeName was not found
//! \return Returns value of the attribute previously set by setAttribute() //! \return Returns value of the attribute previously set by setAttribute()
virtual s32 getAttributeAsInt(const c8* attributeName, irr::s32 defaultNotFound=0) const = 0; virtual s32 getAttributeAsInt(const c8 *attributeName, irr::s32 defaultNotFound = 0) const = 0;
//! Gets an attribute as integer value //! Gets an attribute as integer value
//! \param index: Index value, must be between 0 and getAttributeCount()-1. //! \param index: Index value, must be between 0 and getAttributeCount()-1.
@ -81,16 +79,16 @@ public:
*/ */
//! Adds an attribute as float //! Adds an attribute as float
virtual void addFloat(const c8* attributeName, f32 value) = 0; virtual void addFloat(const c8 *attributeName, f32 value) = 0;
//! Sets a attribute as float value //! Sets a attribute as float value
virtual void setAttribute(const c8* attributeName, f32 value) = 0; virtual void setAttribute(const c8 *attributeName, f32 value) = 0;
//! Gets an attribute as float value //! Gets an attribute as float value
//! \param attributeName: Name of the attribute to get. //! \param attributeName: Name of the attribute to get.
//! \param defaultNotFound Value returned when attributeName was not found //! \param defaultNotFound Value returned when attributeName was not found
//! \return Returns value of the attribute previously set by setAttribute() //! \return Returns value of the attribute previously set by setAttribute()
virtual f32 getAttributeAsFloat(const c8* attributeName, irr::f32 defaultNotFound=0.f) const = 0; virtual f32 getAttributeAsFloat(const c8 *attributeName, irr::f32 defaultNotFound = 0.f) const = 0;
//! Gets an attribute as float value //! Gets an attribute as float value
//! \param index: Index value, must be between 0 and getAttributeCount()-1. //! \param index: Index value, must be between 0 and getAttributeCount()-1.
@ -99,22 +97,21 @@ public:
//! Sets an attribute as float value //! Sets an attribute as float value
virtual void setAttribute(s32 index, f32 value) = 0; virtual void setAttribute(s32 index, f32 value) = 0;
/* /*
Bool Attribute Bool Attribute
*/ */
//! Adds an attribute as bool //! Adds an attribute as bool
virtual void addBool(const c8* attributeName, bool value) = 0; virtual void addBool(const c8 *attributeName, bool value) = 0;
//! Sets an attribute as boolean value //! Sets an attribute as boolean value
virtual void setAttribute(const c8* attributeName, bool value) = 0; virtual void setAttribute(const c8 *attributeName, bool value) = 0;
//! Gets an attribute as boolean value //! Gets an attribute as boolean value
//! \param attributeName: Name of the attribute to get. //! \param attributeName: Name of the attribute to get.
//! \param defaultNotFound Value returned when attributeName was not found //! \param defaultNotFound Value returned when attributeName was not found
//! \return Returns value of the attribute previously set by setAttribute() //! \return Returns value of the attribute previously set by setAttribute()
virtual bool getAttributeAsBool(const c8* attributeName, bool defaultNotFound=false) const = 0; virtual bool getAttributeAsBool(const c8 *attributeName, bool defaultNotFound = false) const = 0;
//! Gets an attribute as boolean value //! Gets an attribute as boolean value
//! \param index: Index value, must be between 0 and getAttributeCount()-1. //! \param index: Index value, must be between 0 and getAttributeCount()-1.
@ -122,7 +119,6 @@ public:
//! Sets an attribute as boolean value //! Sets an attribute as boolean value
virtual void setAttribute(s32 index, bool value) = 0; virtual void setAttribute(s32 index, bool value) = 0;
}; };
} // end namespace io } // end namespace io

37
include/IBillboardSceneNode.h
View File

@ -10,8 +10,8 @@ namespace irr
{ {
namespace scene namespace scene
{ {
class ICameraSceneNode; class ICameraSceneNode;
class IMeshBuffer; class IMeshBuffer;
//! A billboard scene node. //! A billboard scene node.
/** A billboard is like a 3d sprite: A 2d element, /** A billboard is like a 3d sprite: A 2d element,
@ -21,14 +21,13 @@ lensflares, particles and things like that.
class IBillboardSceneNode : public ISceneNode class IBillboardSceneNode : public ISceneNode
{ {
public: public:
//! Constructor //! Constructor
IBillboardSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id, IBillboardSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id,
const core::vector3df& position = core::vector3df(0,0,0)) const core::vector3df &position = core::vector3df(0, 0, 0)) :
: ISceneNode(parent, mgr, id, position) {} ISceneNode(parent, mgr, id, position) {}
//! Sets the size of the billboard, making it rectangular. //! Sets the size of the billboard, making it rectangular.
virtual void setSize(const core::dimension2d<f32>& size) = 0; virtual void setSize(const core::dimension2d<f32> &size) = 0;
//! Sets the size of the billboard with independent widths of the bottom and top edges. //! Sets the size of the billboard with independent widths of the bottom and top edges.
/** \param[in] height The height of the billboard. /** \param[in] height The height of the billboard.
@ -42,38 +41,38 @@ public:
Use getWidths() to retrieve the bottom and top edges independently. Use getWidths() to retrieve the bottom and top edges independently.
\return Size of the billboard. \return Size of the billboard.
*/ */
virtual const core::dimension2d<f32>& getSize() const = 0; virtual const core::dimension2d<f32> &getSize() const = 0;
//! Gets the size of the the billboard and handles independent top and bottom edge widths correctly. //! Gets the size of the the billboard and handles independent top and bottom edge widths correctly.
/** \param[out] height The height of the billboard. /** \param[out] height The height of the billboard.
\param[out] bottomEdgeWidth The width of the bottom edge of the billboard. \param[out] bottomEdgeWidth The width of the bottom edge of the billboard.
\param[out] topEdgeWidth The width of the top edge of the billboard. \param[out] topEdgeWidth The width of the top edge of the billboard.
*/ */
virtual void getSize(f32& height, f32& bottomEdgeWidth, f32& topEdgeWidth) const =0; virtual void getSize(f32 &height, f32 &bottomEdgeWidth, f32 &topEdgeWidth) const = 0;
//! Set the color of all vertices of the billboard //! Set the color of all vertices of the billboard
/** \param[in] overallColor Color to set */ /** \param[in] overallColor Color to set */
virtual void setColor(const video::SColor& overallColor) = 0; virtual void setColor(const video::SColor &overallColor) = 0;
//! Set the color of the top and bottom vertices of the billboard //! Set the color of the top and bottom vertices of the billboard
/** \param[in] topColor Color to set the top vertices /** \param[in] topColor Color to set the top vertices
\param[in] bottomColor Color to set the bottom vertices */ \param[in] bottomColor Color to set the bottom vertices */
virtual void setColor(const video::SColor& topColor, virtual void setColor(const video::SColor &topColor,
const video::SColor& bottomColor) = 0; const video::SColor &bottomColor) = 0;
//! Gets the color of the top and bottom vertices of the billboard //! Gets the color of the top and bottom vertices of the billboard
/** \param[out] topColor Stores the color of the top vertices /** \param[out] topColor Stores the color of the top vertices
\param[out] bottomColor Stores the color of the bottom vertices */ \param[out] bottomColor Stores the color of the bottom vertices */
virtual void getColor(video::SColor& topColor, virtual void getColor(video::SColor &topColor,
video::SColor& bottomColor) const = 0; video::SColor &bottomColor) const = 0;
//! Get the real boundingbox used by the billboard, which can depend on the active camera. //! Get the real boundingbox used by the billboard, which can depend on the active camera.
/** The boundingbox returned will use absolute coordinates. /** The boundingbox returned will use absolute coordinates.
The billboard orients itself toward the camera and some only update in render(). The billboard orients itself toward the camera and some only update in render().
So we don't know the real boundingboxes before that. Which would be too late for culling. So we don't know the real boundingboxes before that. Which would be too late for culling.
That is why the usual getBoundingBox will return a "safe" boundingbox which is guaranteed That is why the usual getBoundingBox will return a "safe" boundingbox which is guaranteed
to contain the billboard. While this function can return the real one. */ to contain the billboard. While this function can return the real one. */
virtual const core::aabbox3d<f32>& getTransformedBillboardBoundingBox(const irr::scene::ICameraSceneNode* camera) = 0; virtual const core::aabbox3d<f32> &getTransformedBillboardBoundingBox(const irr::scene::ICameraSceneNode *camera) = 0;
//! Get the amount of mesh buffers. //! Get the amount of mesh buffers.
/** \return Amount of mesh buffers (IMeshBuffer) in this mesh. */ /** \return Amount of mesh buffers (IMeshBuffer) in this mesh. */
@ -84,7 +83,7 @@ public:
So this is mainly useful to access/modify the uv-coordinates. So this is mainly useful to access/modify the uv-coordinates.
\param nr: Zero based index of the mesh buffer. \param nr: Zero based index of the mesh buffer.
\return Pointer to the mesh buffer or 0 if there is no such mesh buffer. */ \return Pointer to the mesh buffer or 0 if there is no such mesh buffer. */
virtual IMeshBuffer* getMeshBuffer(u32 nr) const = 0; virtual IMeshBuffer *getMeshBuffer(u32 nr) const = 0;
}; };
} // end namespace scene } // end namespace scene

125
include/IBoneSceneNode.h
View File

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

321
include/ICameraSceneNode.h
View File

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

68
include/IContextManager.h
View File

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

303
include/ICursorControl.h
View File

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

7
include/IDummyTransformationSceneNode.h
View File

@ -22,15 +22,14 @@ joint scene nodes when playing skeletal animations.
class IDummyTransformationSceneNode : public ISceneNode class IDummyTransformationSceneNode : public ISceneNode
{ {
public: public:
//! Constructor //! Constructor
IDummyTransformationSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id) IDummyTransformationSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id) :
: ISceneNode(parent, mgr, id) {} ISceneNode(parent, mgr, id) {}
//! Returns a reference to the current relative transformation matrix. //! Returns a reference to the current relative transformation matrix.
/** This is the matrix, this scene node uses instead of scale, translation /** This is the matrix, this scene node uses instead of scale, translation
and rotation. */ and rotation. */
virtual core::matrix4& getRelativeTransformationMatrix() = 0; virtual core::matrix4 &getRelativeTransformationMatrix() = 0;
}; };
} // end namespace scene } // end namespace scene

548
include/IEventReceiver.h
View File

@ -10,304 +10,303 @@
namespace irr namespace irr
{ {
//! Enumeration for all event types there are. //! Enumeration for all event types there are.
enum EEVENT_TYPE enum EEVENT_TYPE
{ {
//! An event of the graphical user interface. //! An event of the graphical user interface.
/** GUI events are created by the GUI environment or the GUI elements in response /** GUI events are created by the GUI environment or the GUI elements in response
to mouse or keyboard events. When a GUI element receives an event it will either to mouse or keyboard events. When a GUI element receives an event it will either
process it and return true, or pass the event to its parent. If an event is not absorbed process it and return true, or pass the event to its parent. If an event is not absorbed
before it reaches the root element then it will then be passed to the user receiver. */ before it reaches the root element then it will then be passed to the user receiver. */
EET_GUI_EVENT = 0, EET_GUI_EVENT = 0,
//! A mouse input event. //! A mouse input event.
/** Mouse events are created by the device and passed to IrrlichtDevice::postEventFromUser /** Mouse events are created by the device and passed to IrrlichtDevice::postEventFromUser
in response to mouse input received from the operating system. in response to mouse input received from the operating system.
Mouse events are first passed to the user receiver, then to the GUI environment and its elements, Mouse events are first passed to the user receiver, then to the GUI environment and its elements,
then finally the input receiving scene manager where it is passed to the active camera. then finally the input receiving scene manager where it is passed to the active camera.
*/ */
EET_MOUSE_INPUT_EVENT, EET_MOUSE_INPUT_EVENT,
//! A key input event. //! A key input event.
/** Like mouse events, keyboard events are created by the device and passed to /** Like mouse events, keyboard events are created by the device and passed to
IrrlichtDevice::postEventFromUser. They take the same path as mouse events. */ IrrlichtDevice::postEventFromUser. They take the same path as mouse events. */
EET_KEY_INPUT_EVENT, EET_KEY_INPUT_EVENT,
//! A string input event. //! A string input event.
/** This event is created when multiple characters are sent at a time (e.g. using an IME). */ /** This event is created when multiple characters are sent at a time (e.g. using an IME). */
EET_STRING_INPUT_EVENT, EET_STRING_INPUT_EVENT,
//! A touch input event. //! A touch input event.
EET_TOUCH_INPUT_EVENT, EET_TOUCH_INPUT_EVENT,
//! A accelerometer event. //! A accelerometer event.
EET_ACCELEROMETER_EVENT, EET_ACCELEROMETER_EVENT,
//! A gyroscope event. //! A gyroscope event.
EET_GYROSCOPE_EVENT, EET_GYROSCOPE_EVENT,
//! A device motion event. //! A device motion event.
EET_DEVICE_MOTION_EVENT, EET_DEVICE_MOTION_EVENT,
//! A joystick (joypad, gamepad) input event. //! A joystick (joypad, gamepad) input event.
/** Joystick events are created by polling all connected joysticks once per /** Joystick events are created by polling all connected joysticks once per
device run() and then passing the events to IrrlichtDevice::postEventFromUser. device run() and then passing the events to IrrlichtDevice::postEventFromUser.
They take the same path as mouse events. They take the same path as mouse events.
Windows, SDL: Implemented. Windows, SDL: Implemented.
Linux: Implemented, with POV hat issues. Linux: Implemented, with POV hat issues.
MacOS / Other: Not yet implemented. MacOS / Other: Not yet implemented.
*/ */
EET_JOYSTICK_INPUT_EVENT, EET_JOYSTICK_INPUT_EVENT,
//! A log event //! A log event
/** Log events are only passed to the user receiver if there is one. If they are absorbed by the /** Log events are only passed to the user receiver if there is one. If they are absorbed by the
user receiver then no text will be sent to the console. */ user receiver then no text will be sent to the console. */
EET_LOG_TEXT_EVENT, EET_LOG_TEXT_EVENT,
//! A user event with user data. //! A user event with user data.
/** This is not used by Irrlicht and can be used to send user /** This is not used by Irrlicht and can be used to send user
specific data though the system. The Irrlicht 'window handle' specific data though the system. The Irrlicht 'window handle'
can be obtained from IrrlichtDevice::getExposedVideoData() can be obtained from IrrlichtDevice::getExposedVideoData()
The usage and behavior depends on the operating system: The usage and behavior depends on the operating system:
Windows: send a WM_USER message to the Irrlicht Window; the Windows: send a WM_USER message to the Irrlicht Window; the
wParam and lParam will be used to populate the wParam and lParam will be used to populate the
UserData1 and UserData2 members of the SUserEvent. UserData1 and UserData2 members of the SUserEvent.
Linux: send a ClientMessage via XSendEvent to the Irrlicht Linux: send a ClientMessage via XSendEvent to the Irrlicht
Window; the data.l[0] and data.l[1] members will be Window; the data.l[0] and data.l[1] members will be
cast to s32 and used as UserData1 and UserData2. cast to s32 and used as UserData1 and UserData2.
MacOS: Not yet implemented MacOS: Not yet implemented
*/ */
EET_USER_EVENT, EET_USER_EVENT,
//! Pass on raw events from the OS //! Pass on raw events from the OS
EET_SYSTEM_EVENT, EET_SYSTEM_EVENT,
//! Application state events like a resume, pause etc. //! Application state events like a resume, pause etc.
EET_APPLICATION_EVENT, EET_APPLICATION_EVENT,
//! This enum is never used, it only forces the compiler to //! This enum is never used, it only forces the compiler to
//! compile these enumeration values to 32 bit. //! compile these enumeration values to 32 bit.
EGUIET_FORCE_32_BIT = 0x7fffffff EGUIET_FORCE_32_BIT = 0x7fffffff
}; };
//! Enumeration for all mouse input events //! Enumeration for all mouse input events
enum EMOUSE_INPUT_EVENT enum EMOUSE_INPUT_EVENT
{ {
//! Left mouse button was pressed down. //! Left mouse button was pressed down.
EMIE_LMOUSE_PRESSED_DOWN = 0, EMIE_LMOUSE_PRESSED_DOWN = 0,
//! Right mouse button was pressed down. //! Right mouse button was pressed down.
EMIE_RMOUSE_PRESSED_DOWN, EMIE_RMOUSE_PRESSED_DOWN,
//! Middle mouse button was pressed down. //! Middle mouse button was pressed down.
EMIE_MMOUSE_PRESSED_DOWN, EMIE_MMOUSE_PRESSED_DOWN,
//! Left mouse button was left up. //! Left mouse button was left up.
EMIE_LMOUSE_LEFT_UP, EMIE_LMOUSE_LEFT_UP,
//! Right mouse button was left up. //! Right mouse button was left up.
EMIE_RMOUSE_LEFT_UP, EMIE_RMOUSE_LEFT_UP,
//! Middle mouse button was left up. //! Middle mouse button was left up.
EMIE_MMOUSE_LEFT_UP, EMIE_MMOUSE_LEFT_UP,
//! The mouse cursor changed its position. //! The mouse cursor changed its position.
EMIE_MOUSE_MOVED, EMIE_MOUSE_MOVED,
//! The mouse wheel was moved. Use Wheel value in event data to find out //! The mouse wheel was moved. Use Wheel value in event data to find out
//! in what direction and how fast. //! in what direction and how fast.
EMIE_MOUSE_WHEEL, EMIE_MOUSE_WHEEL,
//! Left mouse button double click. //! Left mouse button double click.
//! This event is generated after the second EMIE_LMOUSE_PRESSED_DOWN event. //! This event is generated after the second EMIE_LMOUSE_PRESSED_DOWN event.
EMIE_LMOUSE_DOUBLE_CLICK, EMIE_LMOUSE_DOUBLE_CLICK,
//! Right mouse button double click. //! Right mouse button double click.
//! This event is generated after the second EMIE_RMOUSE_PRESSED_DOWN event. //! This event is generated after the second EMIE_RMOUSE_PRESSED_DOWN event.
EMIE_RMOUSE_DOUBLE_CLICK, EMIE_RMOUSE_DOUBLE_CLICK,
//! Middle mouse button double click. //! Middle mouse button double click.
//! This event is generated after the second EMIE_MMOUSE_PRESSED_DOWN event. //! This event is generated after the second EMIE_MMOUSE_PRESSED_DOWN event.
EMIE_MMOUSE_DOUBLE_CLICK, EMIE_MMOUSE_DOUBLE_CLICK,
//! Left mouse button triple click. //! Left mouse button triple click.
//! This event is generated after the third EMIE_LMOUSE_PRESSED_DOWN event. //! This event is generated after the third EMIE_LMOUSE_PRESSED_DOWN event.
EMIE_LMOUSE_TRIPLE_CLICK, EMIE_LMOUSE_TRIPLE_CLICK,
//! Right mouse button triple click. //! Right mouse button triple click.
//! This event is generated after the third EMIE_RMOUSE_PRESSED_DOWN event. //! This event is generated after the third EMIE_RMOUSE_PRESSED_DOWN event.
EMIE_RMOUSE_TRIPLE_CLICK, EMIE_RMOUSE_TRIPLE_CLICK,
//! Middle mouse button triple click. //! Middle mouse button triple click.
//! This event is generated after the third EMIE_MMOUSE_PRESSED_DOWN event. //! This event is generated after the third EMIE_MMOUSE_PRESSED_DOWN event.
EMIE_MMOUSE_TRIPLE_CLICK, EMIE_MMOUSE_TRIPLE_CLICK,
//! Mouse enters canvas used for rendering. //! Mouse enters canvas used for rendering.
//! Only generated on emscripten //! Only generated on emscripten
EMIE_MOUSE_ENTER_CANVAS, EMIE_MOUSE_ENTER_CANVAS,
//! Mouse leaves canvas used for rendering. //! Mouse leaves canvas used for rendering.
//! Only generated on emscripten //! Only generated on emscripten
EMIE_MOUSE_LEAVE_CANVAS, EMIE_MOUSE_LEAVE_CANVAS,
//! No real event. Just for convenience to get number of events //! No real event. Just for convenience to get number of events
EMIE_COUNT EMIE_COUNT
}; };
//! Masks for mouse button states //! Masks for mouse button states
enum E_MOUSE_BUTTON_STATE_MASK enum E_MOUSE_BUTTON_STATE_MASK
{ {
EMBSM_LEFT = 0x01, EMBSM_LEFT = 0x01,
EMBSM_RIGHT = 0x02, EMBSM_RIGHT = 0x02,
EMBSM_MIDDLE = 0x04, EMBSM_MIDDLE = 0x04,
//! currently only on windows //! currently only on windows
EMBSM_EXTRA1 = 0x08, EMBSM_EXTRA1 = 0x08,
//! currently only on windows //! currently only on windows
EMBSM_EXTRA2 = 0x10, EMBSM_EXTRA2 = 0x10,
EMBSM_FORCE_32_BIT = 0x7fffffff EMBSM_FORCE_32_BIT = 0x7fffffff
}; };
//! Enumeration for all touch input events //! Enumeration for all touch input events
enum ETOUCH_INPUT_EVENT enum ETOUCH_INPUT_EVENT
{ {
//! Touch was pressed down. //! Touch was pressed down.
ETIE_PRESSED_DOWN = 0, ETIE_PRESSED_DOWN = 0,
//! Touch was left up. //! Touch was left up.
ETIE_LEFT_UP, ETIE_LEFT_UP,
//! The touch changed its position. //! The touch changed its position.
ETIE_MOVED, ETIE_MOVED,
//! No real event. Just for convenience to get number of events //! No real event. Just for convenience to get number of events
ETIE_COUNT ETIE_COUNT
}; };
enum ESYSTEM_EVENT_TYPE enum ESYSTEM_EVENT_TYPE
{ {
//! From Android command handler for native activity messages //! From Android command handler for native activity messages
ESET_ANDROID_CMD = 0, ESET_ANDROID_CMD = 0,
// TODO: for example ESET_WINDOWS_MESSAGE for win32 message loop events // TODO: for example ESET_WINDOWS_MESSAGE for win32 message loop events
//! No real event, but to get number of event types //! No real event, but to get number of event types
ESET_COUNT ESET_COUNT
}; };
//! Enumeration for a commonly used application state events (it's useful mainly for mobile devices) //! Enumeration for a commonly used application state events (it's useful mainly for mobile devices)
enum EAPPLICATION_EVENT_TYPE enum EAPPLICATION_EVENT_TYPE
{ {
//! The application will be resumed. //! The application will be resumed.
EAET_WILL_RESUME = 0, EAET_WILL_RESUME = 0,
//! The application has been resumed. //! The application has been resumed.
EAET_DID_RESUME, EAET_DID_RESUME,
//! The application will be paused. //! The application will be paused.
EAET_WILL_PAUSE, EAET_WILL_PAUSE,
//! The application has been paused. //! The application has been paused.
EAET_DID_PAUSE, EAET_DID_PAUSE,
//! The application will be terminated. //! The application will be terminated.
EAET_WILL_TERMINATE, EAET_WILL_TERMINATE,
//! The application received a memory warning. //! The application received a memory warning.
EAET_MEMORY_WARNING, EAET_MEMORY_WARNING,
//! No real event, but to get number of event types. //! No real event, but to get number of event types.
EAET_COUNT EAET_COUNT
}; };
namespace gui namespace gui
{ {
class IGUIElement; class IGUIElement;
//! Enumeration for all events which are sendable by the gui system //! Enumeration for all events which are sendable by the gui system
enum EGUI_EVENT_TYPE enum EGUI_EVENT_TYPE
{ {
//! A gui element has lost its focus. //! A gui element has lost its focus.
/** GUIEvent.Caller is losing the focus to GUIEvent.Element. /** GUIEvent.Caller is losing the focus to GUIEvent.Element.
If the event is absorbed then the focus will not be changed. */ If the event is absorbed then the focus will not be changed. */
EGET_ELEMENT_FOCUS_LOST = 0, EGET_ELEMENT_FOCUS_LOST = 0,
//! A gui element has got the focus. //! A gui element has got the focus.
/** If the event is absorbed then the focus will not be changed. */ /** If the event is absorbed then the focus will not be changed. */
EGET_ELEMENT_FOCUSED, EGET_ELEMENT_FOCUSED,
//! The mouse cursor hovered over a gui element. //! The mouse cursor hovered over a gui element.
/** If an element has sub-elements you also get this message for the subelements */ /** If an element has sub-elements you also get this message for the subelements */
EGET_ELEMENT_HOVERED, EGET_ELEMENT_HOVERED,
//! The mouse cursor left the hovered element. //! The mouse cursor left the hovered element.
/** If an element has sub-elements you also get this message for the subelements */ /** If an element has sub-elements you also get this message for the subelements */
EGET_ELEMENT_LEFT, EGET_ELEMENT_LEFT,
//! An element would like to close. //! An element would like to close.
/** Windows and context menus use this event when they would like to close, /** Windows and context menus use this event when they would like to close,
this can be canceled by absorbing the event. */ this can be canceled by absorbing the event. */
EGET_ELEMENT_CLOSED, EGET_ELEMENT_CLOSED,
//! A button was clicked. //! A button was clicked.
EGET_BUTTON_CLICKED, EGET_BUTTON_CLICKED,
//! A scrollbar has changed its position. //! A scrollbar has changed its position.
EGET_SCROLL_BAR_CHANGED, EGET_SCROLL_BAR_CHANGED,
//! 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. //! A listbox would like to open.
/** You can prevent the listbox from opening by absorbing the event. */ /** You can prevent the listbox from opening by absorbing the event. */
EGET_LISTBOX_OPENED, 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,
//! An item in the listbox was selected, which was already selected. //! An item in the listbox was selected, which was already selected.
/** NOTE: You get the event currently only if the item was clicked again within 500 ms or selected by "enter" or "space". */ /** NOTE: You get the event currently only if the item was clicked again within 500 ms or selected by "enter" or "space". */
EGET_LISTBOX_SELECTED_AGAIN, EGET_LISTBOX_SELECTED_AGAIN,
//! A file has been selected in the file dialog //! A file has been selected in the file dialog
EGET_FILE_SELECTED, EGET_FILE_SELECTED,
//! A directory has been selected in the file dialog //! A directory has been selected in the file dialog
EGET_DIRECTORY_SELECTED, EGET_DIRECTORY_SELECTED,
//! A file open dialog has been closed without choosing a file //! A file open dialog has been closed without choosing a file
EGET_FILE_CHOOSE_DIALOG_CANCELLED, EGET_FILE_CHOOSE_DIALOG_CANCELLED,
//! In an editbox 'ENTER' was pressed //! In an editbox 'ENTER' was pressed
EGET_EDITBOX_ENTER, EGET_EDITBOX_ENTER,
//! The text in an editbox was changed. This does not include automatic changes in text-breaking. //! The text in an editbox was changed. This does not include automatic changes in text-breaking.
EGET_EDITBOX_CHANGED, EGET_EDITBOX_CHANGED,
//! The marked area in an editbox was changed. //! The marked area in an editbox was changed.
EGET_EDITBOX_MARKING_CHANGED, EGET_EDITBOX_MARKING_CHANGED,
//! The tab was changed in an tab control //! The tab was changed in an tab control
EGET_TAB_CHANGED, EGET_TAB_CHANGED,
//! The selection in a combo box has been changed //! The selection in a combo box has been changed
EGET_COMBO_BOX_CHANGED, EGET_COMBO_BOX_CHANGED,
//! A table has changed //! A table has changed
EGET_TABLE_CHANGED, EGET_TABLE_CHANGED,
EGET_TABLE_HEADER_CHANGED, EGET_TABLE_HEADER_CHANGED,
EGET_TABLE_SELECTED_AGAIN, EGET_TABLE_SELECTED_AGAIN,
//! No real event. Just for convenience to get number of events
EGET_COUNT
};
} // end namespace gui
//! No real event. Just for convenience to get number of events
EGET_COUNT
};
} // end namespace gui
//! SEvents hold information about an event. See irr::IEventReceiver for details on event handling. //! SEvents hold information about an event. See irr::IEventReceiver for details on event handling.
struct SEvent struct SEvent
@ -316,14 +315,13 @@ struct SEvent
struct SGUIEvent struct SGUIEvent
{ {
//! IGUIElement who called the event //! IGUIElement who called the event
gui::IGUIElement* Caller; gui::IGUIElement *Caller;
//! If the event has something to do with another element, it will be held here. //! If the event has something to do with another element, it will be held here.
gui::IGUIElement* Element; gui::IGUIElement *Element;
//! Type of GUI Event //! Type of GUI Event
gui::EGUI_EVENT_TYPE EventType; gui::EGUI_EVENT_TYPE EventType;
}; };
//! Any kind of mouse event. //! Any kind of mouse event.
@ -340,10 +338,10 @@ struct SEvent
f32 Wheel; f32 Wheel;
//! True if shift was also pressed //! True if shift was also pressed
bool Shift:1; bool Shift : 1;
//! True if ctrl was also pressed //! True if ctrl was also pressed
bool Control:1; bool Control : 1;
//! A bitmap of button states. You can use isButtonPressed() to determine //! A bitmap of button states. You can use isButtonPressed() to determine
//! if a button is pressed or not. //! if a button is pressed or not.
@ -351,13 +349,13 @@ struct SEvent
u32 ButtonStates; u32 ButtonStates;
//! Is the left button pressed down? //! Is the left button pressed down?
bool isLeftPressed() const { return 0 != ( ButtonStates & EMBSM_LEFT ); } bool isLeftPressed() const { return 0 != (ButtonStates & EMBSM_LEFT); }
//! Is the right button pressed down? //! Is the right button pressed down?
bool isRightPressed() const { return 0 != ( ButtonStates & EMBSM_RIGHT ); } bool isRightPressed() const { return 0 != (ButtonStates & EMBSM_RIGHT); }
//! Is the middle button pressed down? //! Is the middle button pressed down?
bool isMiddlePressed() const { return 0 != ( ButtonStates & EMBSM_MIDDLE ); } bool isMiddlePressed() const { return 0 != (ButtonStates & EMBSM_MIDDLE); }
//! Type of mouse event //! Type of mouse event
EMOUSE_INPUT_EVENT Event; EMOUSE_INPUT_EVENT Event;
@ -377,13 +375,13 @@ struct SEvent
u32 SystemKeyCode; u32 SystemKeyCode;
//! If not true, then the key was left up //! If not true, then the key was left up
bool PressedDown:1; bool PressedDown : 1;
//! True if shift was also pressed //! True if shift was also pressed
bool Shift:1; bool Shift : 1;
//! True if ctrl was also pressed //! True if ctrl was also pressed
bool Control:1; bool Control : 1;
}; };
//! String input event. //! String input event.
@ -425,7 +423,7 @@ struct SEvent
f64 Z; f64 Z;
}; };
//! Any kind of gyroscope event. //! Any kind of gyroscope event.
struct SGyroscopeEvent struct SGyroscopeEvent
{ {
// X rotation. // X rotation.
@ -465,13 +463,13 @@ struct SEvent
{ {
NUMBER_OF_BUTTONS = 32, NUMBER_OF_BUTTONS = 32,
AXIS_X = 0, // e.g. analog stick 1 left to right AXIS_X = 0, // e.g. analog stick 1 left to right
AXIS_Y, // e.g. analog stick 1 top to bottom AXIS_Y, // e.g. analog stick 1 top to bottom
AXIS_Z, // e.g. throttle, or analog 2 stick 2 left to right AXIS_Z, // e.g. throttle, or analog 2 stick 2 left to right
AXIS_R, // e.g. rudder, or analog 2 stick 2 top to bottom AXIS_R, // e.g. rudder, or analog 2 stick 2 top to bottom
AXIS_U, AXIS_U,
AXIS_V, AXIS_V,
NUMBER_OF_AXES=18 // (please tell Irrlicht maintainers if you absolutely need more axes) NUMBER_OF_AXES = 18 // (please tell Irrlicht maintainers if you absolutely need more axes)
}; };
/** A bitmap of button states. You can use IsButtonPressed() to /** A bitmap of button states. You can use IsButtonPressed() to
@ -503,7 +501,7 @@ struct SEvent
//! A helper function to check if a button is pressed. //! A helper function to check if a button is pressed.
bool IsButtonPressed(u32 button) const bool IsButtonPressed(u32 button) const
{ {
if(button >= (u32)NUMBER_OF_BUTTONS) if (button >= (u32)NUMBER_OF_BUTTONS)
return false; return false;
return (ButtonStates & (1 << button)) ? true : false; return (ButtonStates & (1 << button)) ? true : false;
@ -514,7 +512,7 @@ struct SEvent
struct SLogEvent struct SLogEvent
{ {
//! Pointer to text which has been logged //! Pointer to text which has been logged
const c8* Text; const c8 *Text;
//! Log level in which the text has been logged //! Log level in which the text has been logged
ELOG_LEVEL Level; ELOG_LEVEL Level;
@ -572,7 +570,6 @@ struct SEvent
struct SSystemEvent SystemEvent; struct SSystemEvent SystemEvent;
struct SApplicationEvent ApplicationEvent; struct SApplicationEvent ApplicationEvent;
}; };
}; };
//! Interface of an object which can receive events. //! Interface of an object which can receive events.
@ -584,7 +581,6 @@ path it takes through the system. */
class IEventReceiver class IEventReceiver
{ {
public: public:
//! Destructor //! Destructor
virtual ~IEventReceiver() {} virtual ~IEventReceiver() {}
@ -594,10 +590,9 @@ public:
* Therefore your return value for all unprocessed events should be 'false'. * Therefore your return value for all unprocessed events should be 'false'.
\return True if the event was processed. \return True if the event was processed.
*/ */
virtual bool OnEvent(const SEvent& event) = 0; virtual bool OnEvent(const SEvent &event) = 0;
}; };
//! Information on a joystick, returned from @ref irr::IrrlichtDevice::activateJoysticks() //! Information on a joystick, returned from @ref irr::IrrlichtDevice::activateJoysticks()
struct SJoystickInfo struct SJoystickInfo
{ {
@ -634,5 +629,4 @@ struct SJoystickInfo
} PovHat; } PovHat;
}; // struct SJoystickInfo }; // struct SJoystickInfo
} // end namespace irr } // end namespace irr

34
include/IFileArchive.h
View File

@ -16,54 +16,53 @@ namespace io
//! FileSystemType: which filesystem should be used for e.g. browsing //! FileSystemType: which filesystem should be used for e.g. browsing
enum EFileSystemType enum EFileSystemType
{ {
FILESYSTEM_NATIVE = 0, // Native OS FileSystem FILESYSTEM_NATIVE = 0, // Native OS FileSystem
FILESYSTEM_VIRTUAL // Virtual FileSystem FILESYSTEM_VIRTUAL // Virtual FileSystem
}; };
//! Contains the different types of archives //! Contains the different types of archives
enum E_FILE_ARCHIVE_TYPE enum E_FILE_ARCHIVE_TYPE
{ {
//! A PKZIP archive //! A PKZIP archive
EFAT_ZIP = MAKE_IRR_ID('Z','I','P', 0), EFAT_ZIP = MAKE_IRR_ID('Z', 'I', 'P', 0),
//! A gzip archive //! A gzip archive
EFAT_GZIP = MAKE_IRR_ID('g','z','i','p'), EFAT_GZIP = MAKE_IRR_ID('g', 'z', 'i', 'p'),
//! An Android asset file archive //! An Android asset file archive
EFAT_ANDROID_ASSET = MAKE_IRR_ID('A','S','S','E'), EFAT_ANDROID_ASSET = MAKE_IRR_ID('A', 'S', 'S', 'E'),
//! The type of this archive is unknown //! The type of this archive is unknown
EFAT_UNKNOWN = MAKE_IRR_ID('u','n','k','n') EFAT_UNKNOWN = MAKE_IRR_ID('u', 'n', 'k', 'n')
}; };
//! The FileArchive manages archives and provides access to files inside them. //! The FileArchive manages archives and provides access to files inside them.
class IFileArchive : public virtual IReferenceCounted class IFileArchive : public virtual IReferenceCounted
{ {
public: public:
//! Opens a file based on its name //! Opens a file based on its name
/** Creates and returns a new IReadFile for a file in the archive. /** Creates and returns a new IReadFile for a file in the archive.
\param filename The file to open \param filename The file to open
\return Returns A pointer to the created file on success, \return Returns A pointer to the created file on success,
or 0 on failure. */ or 0 on failure. */
virtual IReadFile* createAndOpenFile(const path& filename) =0; virtual IReadFile *createAndOpenFile(const path &filename) = 0;
//! Opens a file based on its position in the file list. //! Opens a file based on its position in the file list.
/** Creates and returns /** Creates and returns
\param index The zero based index of the file. \param index The zero based index of the file.
\return Returns a pointer to the created file on success, or 0 on failure. */ \return Returns a pointer to the created file on success, or 0 on failure. */
virtual IReadFile* createAndOpenFile(u32 index) =0; virtual IReadFile *createAndOpenFile(u32 index) = 0;
//! Returns the complete file tree //! Returns the complete file tree
/** \return Returns the complete directory tree for the archive, /** \return Returns the complete directory tree for the archive,
including all files and folders */ including all files and folders */
virtual const IFileList* getFileList() const =0; virtual const IFileList *getFileList() const = 0;
//! get the archive type //! get the archive type
virtual E_FILE_ARCHIVE_TYPE getType() const { return EFAT_UNKNOWN; } virtual E_FILE_ARCHIVE_TYPE getType() const { return EFAT_UNKNOWN; }
//! return the name (id) of the file Archive //! return the name (id) of the file Archive
virtual const io::path& getArchiveName() const =0; virtual const io::path &getArchiveName() const = 0;
//! Add a directory in the archive and all it's files to the FileList //! Add a directory in the archive and all it's files to the FileList
/** Only needed for file-archives which have no information about their own /** Only needed for file-archives which have no information about their own
@ -95,35 +94,34 @@ public:
/** Check based on the file extension (e.g. ".zip") /** Check based on the file extension (e.g. ".zip")
\param filename Name of file to check. \param filename Name of file to check.
\return True if file seems to be loadable. */ \return True if file seems to be loadable. */
virtual bool isALoadableFileFormat(const path& filename) const =0; virtual bool isALoadableFileFormat(const path &filename) const = 0;
//! Check if the file might be loaded by this class //! Check if the file might be loaded by this class
/** This check may look into the file. /** This check may look into the file.
\param file File handle to check. \param file File handle to check.
\return True if file seems to be loadable. */ \return True if file seems to be loadable. */
virtual bool isALoadableFileFormat(io::IReadFile* file) const =0; virtual bool isALoadableFileFormat(io::IReadFile *file) const = 0;
//! Check to see if the loader can create archives of this type. //! Check to see if the loader can create archives of this type.
/** Check based on the archive type. /** Check based on the archive type.
\param fileType The archive type to check. \param fileType The archive type to check.
\return True if the archive loader supports this type, false if not */ \return True if the archive loader supports this type, false if not */
virtual bool isALoadableFileFormat(E_FILE_ARCHIVE_TYPE fileType) const =0; virtual bool isALoadableFileFormat(E_FILE_ARCHIVE_TYPE fileType) const = 0;
//! Creates an archive from the filename //! Creates an archive from the filename
/** \param filename File to use. /** \param filename File to use.
\param ignoreCase Searching is performed without regarding the case \param ignoreCase Searching is performed without regarding the case
\param ignorePaths Files are searched for without checking for the directories \param ignorePaths Files are searched for without checking for the directories
\return Pointer to newly created archive, or 0 upon error. */ \return Pointer to newly created archive, or 0 upon error. */
virtual IFileArchive* createArchive(const path& filename, bool ignoreCase, bool ignorePaths) const =0; virtual IFileArchive *createArchive(const path &filename, bool ignoreCase, bool ignorePaths) const = 0;
//! Creates an archive from the file //! Creates an archive from the file
/** \param file File handle to use. /** \param file File handle to use.
\param ignoreCase Searching is performed without regarding the case \param ignoreCase Searching is performed without regarding the case
\param ignorePaths Files are searched for without checking for the directories \param ignorePaths Files are searched for without checking for the directories
\return Pointer to newly created archive, or 0 upon error. */ \return Pointer to newly created archive, or 0 upon error. */
virtual IFileArchive* createArchive(io::IReadFile* file, bool ignoreCase, bool ignorePaths) const =0; virtual IFileArchive *createArchive(io::IReadFile *file, bool ignoreCase, bool ignorePaths) const = 0;
}; };
} // end namespace io } // end namespace io
} // end namespace irr } // end namespace irr

10
include/IFileList.h
View File

@ -27,13 +27,13 @@ public:
\param index is the zero based index of the file which name should \param index is the zero based index of the file which name should
be returned. The index must be less than the amount getFileCount() returns. be returned. The index must be less than the amount getFileCount() returns.
\return File name of the file. Returns 0, if an error occurred. */ \return File name of the file. Returns 0, if an error occurred. */
virtual const io::path& getFileName(u32 index) const = 0; virtual const io::path &getFileName(u32 index) const = 0;
//! Gets the full name of a file in the list including the path, based on an index. //! Gets the full name of a file in the list including the path, based on an index.
/** \param index is the zero based index of the file which name should /** \param index is the zero based index of the file which name should
be returned. The index must be less than the amount getFileCount() returns. be returned. The index must be less than the amount getFileCount() returns.
\return File name of the file. Returns 0 if an error occurred. */ \return File name of the file. Returns 0 if an error occurred. */
virtual const io::path& getFullFileName(u32 index) const = 0; virtual const io::path &getFullFileName(u32 index) const = 0;
//! Returns the size of a file in the file list, based on an index. //! Returns the size of a file in the file list, based on an index.
/** \param index is the zero based index of the file which should be returned. /** \param index is the zero based index of the file which should be returned.
@ -68,10 +68,10 @@ public:
\param isFolder True if you are searching for a directory path, false if you are searching for a file \param isFolder True if you are searching for a directory path, false if you are searching for a file
\return Returns the index of the file in the file list, or -1 if \return Returns the index of the file in the file list, or -1 if
no matching name name was found. */ no matching name name was found. */
virtual s32 findFile(const io::path& filename, bool isFolder=false) const = 0; virtual s32 findFile(const io::path &filename, bool isFolder = false) const = 0;
//! Returns the base path of the file list //! Returns the base path of the file list
virtual const io::path& getPath() const = 0; virtual const io::path &getPath() const = 0;
//! Add as a file or folder to the list //! Add as a file or folder to the list
/** \param fullPath The file name including path, from the root of the file list. /** \param fullPath The file name including path, from the root of the file list.
@ -79,7 +79,7 @@ public:
\param offset The file offset inside an archive \param offset The file offset inside an archive
\param size The size of the file in bytes. \param size The size of the file in bytes.
\param id The ID of the file in the archive which owns it */ \param id The ID of the file in the archive which owns it */
virtual u32 addItem(const io::path& fullPath, u32 offset, u32 size, bool isDirectory, u32 id=0) = 0; virtual u32 addItem(const io::path &fullPath, u32 offset, u32 size, bool isDirectory, u32 id = 0) = 0;
//! Sorts the file list. You should call this after adding any items to the file list //! Sorts the file list. You should call this after adding any items to the file list
virtual void sort() = 0; virtual void sort() = 0;

78
include/IFileSystem.h
View File

@ -11,7 +11,7 @@ namespace irr
{ {
namespace video namespace video
{ {
class IVideoDriver; class IVideoDriver;
} // end namespace video } // end namespace video
namespace io namespace io
{ {
@ -21,7 +21,6 @@ class IWriteFile;
class IFileList; class IFileList;
class IAttributes; class IAttributes;
//! The FileSystem manages files and archives and provides access to them. //! The FileSystem manages files and archives and provides access to them.
/** It manages where files are, so that modules which use the the IO do not /** It manages where files are, so that modules which use the the IO do not
need to know where every file is located. A file could be in a .zip-Archive or need to know where every file is located. A file could be in a .zip-Archive or
@ -29,13 +28,12 @@ as file on disk, using the IFileSystem makes no difference to this. */
class IFileSystem : public virtual IReferenceCounted class IFileSystem : public virtual IReferenceCounted
{ {
public: public:
//! Opens a file for read access. //! Opens a file for read access.
/** \param filename: Name of file to open. /** \param filename: Name of file to open.
\return Pointer to the created file interface. \return Pointer to the created file interface.
The returned pointer should be dropped when no longer needed. The returned pointer should be dropped when no longer needed.
See IReferenceCounted::drop() for more information. */ See IReferenceCounted::drop() for more information. */
virtual IReadFile* createAndOpenFile(const path& filename) =0; virtual IReadFile *createAndOpenFile(const path &filename) = 0;
//! Creates an IReadFile interface for accessing memory like a file. //! Creates an IReadFile interface for accessing memory like a file.
/** This allows you to use a pointer to memory where an IReadFile is requested. /** This allows you to use a pointer to memory where an IReadFile is requested.
@ -48,7 +46,7 @@ public:
The returned pointer should be dropped when no longer needed. The returned pointer should be dropped when no longer needed.
See IReferenceCounted::drop() for more information. See IReferenceCounted::drop() for more information.
*/ */
virtual IReadFile* createMemoryReadFile(const void* memory, s32 len, const path& fileName, bool deleteMemoryWhenDropped=false) =0; virtual IReadFile *createMemoryReadFile(const void *memory, s32 len, const path &fileName, bool deleteMemoryWhenDropped = false) = 0;
//! Creates an IReadFile interface for accessing files inside files. //! Creates an IReadFile interface for accessing files inside files.
/** This is useful e.g. for archives. /** This is useful e.g. for archives.
@ -60,8 +58,8 @@ public:
The returned pointer should be dropped when no longer needed. The returned pointer should be dropped when no longer needed.
See IReferenceCounted::drop() for more information. See IReferenceCounted::drop() for more information.
*/ */
virtual IReadFile* createLimitReadFile(const path& fileName, virtual IReadFile *createLimitReadFile(const path &fileName,
IReadFile* alreadyOpenedFile, long pos, long areaSize) =0; IReadFile *alreadyOpenedFile, long pos, long areaSize) = 0;
//! Creates an IWriteFile interface for accessing memory like a file. //! Creates an IWriteFile interface for accessing memory like a file.
/** This allows you to use a pointer to memory where an IWriteFile is requested. /** This allows you to use a pointer to memory where an IWriteFile is requested.
@ -75,8 +73,7 @@ public:
The returned pointer should be dropped when no longer needed. The returned pointer should be dropped when no longer needed.
See IReferenceCounted::drop() for more information. See IReferenceCounted::drop() for more information.
*/ */
virtual IWriteFile* createMemoryWriteFile(void* memory, s32 len, const path& fileName, bool deleteMemoryWhenDropped=false) =0; virtual IWriteFile *createMemoryWriteFile(void *memory, s32 len, const path &fileName, bool deleteMemoryWhenDropped = false) = 0;
//! Opens a file for write access. //! Opens a file for write access.
/** \param filename: Name of file to open. /** \param filename: Name of file to open.
@ -86,7 +83,7 @@ public:
file could not created or opened for writing. file could not created or opened for writing.
The returned pointer should be dropped when no longer needed. The returned pointer should be dropped when no longer needed.
See IReferenceCounted::drop() for more information. */ See IReferenceCounted::drop() for more information. */
virtual IWriteFile* createAndWriteFile(const path& filename, bool append=false) =0; virtual IWriteFile *createAndWriteFile(const path &filename, bool append = false) = 0;
//! Adds an archive to the file system. //! Adds an archive to the file system.
/** After calling this, the Irrlicht Engine will also search and open /** After calling this, the Irrlicht Engine will also search and open
@ -110,11 +107,11 @@ public:
\param password An optional password, which is used in case of encrypted archives. \param password An optional password, which is used in case of encrypted archives.
\param retArchive A pointer that will be set to the archive that is added. \param retArchive A pointer that will be set to the archive that is added.
\return True if the archive was added successfully, false if not. */ \return True if the archive was added successfully, false if not. */
virtual bool addFileArchive(const path& filename, bool ignoreCase=true, virtual bool addFileArchive(const path &filename, bool ignoreCase = true,
bool ignorePaths=true, bool ignorePaths = true,
E_FILE_ARCHIVE_TYPE archiveType=EFAT_UNKNOWN, E_FILE_ARCHIVE_TYPE archiveType = EFAT_UNKNOWN,
const core::stringc& password="", const core::stringc &password = "",
IFileArchive** retArchive=0) =0; IFileArchive **retArchive = 0) = 0;
//! Adds an archive to the file system. //! Adds an archive to the file system.
/** After calling this, the Irrlicht Engine will also search and open /** After calling this, the Irrlicht Engine will also search and open
@ -142,19 +139,19 @@ public:
\param password An optional password, which is used in case of encrypted archives. \param password An optional password, which is used in case of encrypted archives.
\param retArchive A pointer that will be set to the archive that is added. \param retArchive A pointer that will be set to the archive that is added.
\return True if the archive was added successfully, false if not. */ \return True if the archive was added successfully, false if not. */
virtual bool addFileArchive(IReadFile* file, bool ignoreCase=true, virtual bool addFileArchive(IReadFile *file, bool ignoreCase = true,
bool ignorePaths=true, bool ignorePaths = true,
E_FILE_ARCHIVE_TYPE archiveType=EFAT_UNKNOWN, E_FILE_ARCHIVE_TYPE archiveType = EFAT_UNKNOWN,
const core::stringc& password="", const core::stringc &password = "",
IFileArchive** retArchive=0) =0; IFileArchive **retArchive = 0) = 0;
//! Adds an archive to the file system. //! Adds an archive to the file system.
/** \param archive: The archive to add to the file system. /** \param archive: The archive to add to the file system.
\return True if the archive was added successfully, false if not. */ \return True if the archive was added successfully, false if not. */
virtual bool addFileArchive(IFileArchive* archive) =0; virtual bool addFileArchive(IFileArchive *archive) = 0;
//! Get the number of archives currently attached to the file system //! Get the number of archives currently attached to the file system
virtual u32 getFileArchiveCount() const =0; virtual u32 getFileArchiveCount() const = 0;
//! Removes an archive from the file system. //! Removes an archive from the file system.
/** This will close the archive and free any file handles, but will not /** This will close the archive and free any file handles, but will not
@ -162,7 +159,7 @@ public:
example textures and meshes. example textures and meshes.
\param index: The index of the archive to remove \param index: The index of the archive to remove
\return True on success, false on failure */ \return True on success, false on failure */
virtual bool removeFileArchive(u32 index) =0; virtual bool removeFileArchive(u32 index) = 0;
//! Removes an archive from the file system. //! Removes an archive from the file system.
/** This will close the archive and free any file handles, but will not /** This will close the archive and free any file handles, but will not
@ -176,7 +173,7 @@ public:
locating the archive to work with. locating the archive to work with.
\param filename The archive pointed to by the name will be removed \param filename The archive pointed to by the name will be removed
\return True on success, false on failure */ \return True on success, false on failure */
virtual bool removeFileArchive(const path& filename) =0; virtual bool removeFileArchive(const path &filename) = 0;
//! Removes an archive from the file system. //! Removes an archive from the file system.
/** This will close the archive and free any file handles, but will not /** This will close the archive and free any file handles, but will not
@ -184,21 +181,21 @@ public:
example textures and meshes. example textures and meshes.
\param archive The archive to remove. \param archive The archive to remove.
\return True on success, false on failure */ \return True on success, false on failure */
virtual bool removeFileArchive(const IFileArchive* archive) =0; virtual bool removeFileArchive(const IFileArchive *archive) = 0;
//! Changes the search order of attached archives. //! Changes the search order of attached archives.
/** /**
\param sourceIndex: The index of the archive to change \param sourceIndex: The index of the archive to change
\param relative: The relative change in position, archives with a lower index are searched first */ \param relative: The relative change in position, archives with a lower index are searched first */
virtual bool moveFileArchive(u32 sourceIndex, s32 relative) =0; virtual bool moveFileArchive(u32 sourceIndex, s32 relative) = 0;
//! Get the archive at a given index. //! Get the archive at a given index.
virtual IFileArchive* getFileArchive(u32 index) =0; virtual IFileArchive *getFileArchive(u32 index) = 0;
//! Adds an external archive loader to the engine. //! Adds an external archive loader to the engine.
/** Use this function to add support for new archive types to the /** Use this function to add support for new archive types to the
engine, for example proprietary or encrypted file storage. */ engine, for example proprietary or encrypted file storage. */
virtual void addArchiveLoader(IArchiveLoader* loader) =0; virtual void addArchiveLoader(IArchiveLoader *loader) = 0;
//! Gets the number of archive loaders currently added //! Gets the number of archive loaders currently added
virtual u32 getArchiveLoaderCount() const = 0; virtual u32 getArchiveLoaderCount() const = 0;
@ -207,63 +204,62 @@ public:
/** \param index The index of the loader to retrieve. This parameter is an 0-based /** \param index The index of the loader to retrieve. This parameter is an 0-based
array index. array index.
\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;
//! 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;
//! Changes the current working directory. //! Changes the current working directory.
/** \param newDirectory: A string specifying the new working directory. /** \param newDirectory: A string specifying the new working directory.
The string is operating system dependent. Under Windows it has The string is operating system dependent. Under Windows it has
the form "<drive>:\<directory>\<sudirectory>\<..>". An example would be: "C:\Windows\" the form "<drive>:\<directory>\<sudirectory>\<..>". An example would be: "C:\Windows\"
\return True if successful, otherwise false. */ \return True if successful, otherwise false. */
virtual bool changeWorkingDirectoryTo(const path& newDirectory) =0; virtual bool changeWorkingDirectoryTo(const path &newDirectory) = 0;
//! Converts a relative path to an absolute (unique) path, resolving symbolic links if required //! Converts a relative path to an absolute (unique) path, resolving symbolic links if required
/** \param filename Possibly relative file or directory name to query. /** \param filename Possibly relative file or directory name to query.
\result Absolute filename which points to the same file. */ \result Absolute filename which points to the same file. */
virtual path getAbsolutePath(const path& filename) const =0; virtual path getAbsolutePath(const path &filename) const = 0;
//! Get the directory a file is located in. //! Get the directory a file is located in.
/** \param filename: The file to get the directory from. /** \param filename: The file to get the directory from.
\return String containing the directory of the file. */ \return String containing the directory of the file. */
virtual path getFileDir(const path& filename) const =0; virtual path getFileDir(const path &filename) const = 0;
//! Get the base part of a filename, i.e. the name without the directory part. //! Get the base part of a filename, i.e. the name without the directory part.
/** If no directory is prefixed, the full name is returned. /** If no directory is prefixed, the full name is returned.
\param filename: The file to get the basename from \param filename: The file to get the basename from
\param keepExtension True if filename with extension is returned otherwise everything \param keepExtension True if filename with extension is returned otherwise everything
after the final '.' is removed as well. */ after the final '.' is removed as well. */
virtual path getFileBasename(const path& filename, bool keepExtension=true) const =0; virtual path getFileBasename(const path &filename, bool keepExtension = true) const = 0;
//! flatten a path and file name for example: "/you/me/../." becomes "/you" //! flatten a path and file name for example: "/you/me/../." becomes "/you"
virtual path& flattenFilename(path& directory, const path& root="/") const =0; virtual path &flattenFilename(path &directory, const path &root = "/") const = 0;
//! Get the relative filename, relative to the given directory //! Get the relative filename, relative to the given directory
virtual path getRelativeFilename(const path& filename, const path& directory) const =0; virtual path getRelativeFilename(const path &filename, const path &directory) const = 0;
//! Creates a list of files and directories in the current working directory and returns it. //! Creates a list of files and directories in the current working directory and returns it.
/** \return a Pointer to the created IFileList is returned. After the list has been used /** \return a Pointer to the created IFileList is returned. After the list has been used
it has to be deleted using its IFileList::drop() method. it has to be deleted using its IFileList::drop() method.
See IReferenceCounted::drop() for more information. */ See IReferenceCounted::drop() for more information. */
virtual IFileList* createFileList() =0; virtual IFileList *createFileList() = 0;
//! Creates an empty filelist //! Creates an empty filelist
/** \return a Pointer to the created IFileList is returned. After the list has been used /** \return a Pointer to the created IFileList is returned. After the list has been used
it has to be deleted using its IFileList::drop() method. it has to be deleted using its IFileList::drop() method.
See IReferenceCounted::drop() for more information. */ See IReferenceCounted::drop() for more information. */
virtual IFileList* createEmptyFileList(const io::path& path, bool ignoreCase, bool ignorePaths) =0; virtual IFileList *createEmptyFileList(const io::path &path, bool ignoreCase, bool ignorePaths) = 0;
//! Set the active type of file system. //! Set the active type of file system.
virtual EFileSystemType setFileListSystem(EFileSystemType listType) =0; virtual EFileSystemType setFileListSystem(EFileSystemType listType) = 0;
//! Determines if a file exists and could be opened. //! Determines if a file exists and could be opened.
/** \param filename is the string identifying the file which should be tested for existence. /** \param filename is the string identifying the file which should be tested for existence.
\return True if file exists, and false if it does not exist or an error occurred. */ \return True if file exists, and false if it does not exist or an error occurred. */
virtual bool existFile(const path& filename) const =0; virtual bool existFile(const path &filename) const = 0;
}; };
} // end namespace io } // end namespace io
} // end namespace irr } // end namespace irr

288
include/IGPUProgrammingServices.h
View File

@ -14,7 +14,7 @@ namespace irr
namespace io namespace io
{ {
class IReadFile; class IReadFile;
} // end namespace io } // end namespace io
namespace video namespace video
@ -27,7 +27,6 @@ class IShaderConstantSetCallBack;
class IGPUProgrammingServices class IGPUProgrammingServices
{ {
public: public:
//! Destructor //! Destructor
virtual ~IGPUProgrammingServices() {} virtual ~IGPUProgrammingServices() {}
@ -73,41 +72,41 @@ public:
target is not reachable. The error strings are then printed to the target is not reachable. The error strings are then printed to the
error log and can be caught with a custom event receiver. */ error log and can be caught with a custom event receiver. */
virtual s32 addHighLevelShaderMaterial( virtual s32 addHighLevelShaderMaterial(
const c8* vertexShaderProgram, const c8 *vertexShaderProgram,
const c8* vertexShaderEntryPointName, const c8 *vertexShaderEntryPointName,
E_VERTEX_SHADER_TYPE vsCompileTarget, E_VERTEX_SHADER_TYPE vsCompileTarget,
const c8* pixelShaderProgram, const c8 *pixelShaderProgram,
const c8* pixelShaderEntryPointName, const c8 *pixelShaderEntryPointName,
E_PIXEL_SHADER_TYPE psCompileTarget, E_PIXEL_SHADER_TYPE psCompileTarget,
const c8* geometryShaderProgram, const c8 *geometryShaderProgram,
const c8* geometryShaderEntryPointName = "main", const c8 *geometryShaderEntryPointName = "main",
E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0, E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES, scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP, scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
u32 verticesOut = 0, u32 verticesOut = 0,
IShaderConstantSetCallBack* callback = 0, IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID, E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0) = 0; s32 userData = 0) = 0;
//! convenience function for use without geometry shaders //! convenience function for use without geometry shaders
s32 addHighLevelShaderMaterial( s32 addHighLevelShaderMaterial(
const c8* vertexShaderProgram, const c8 *vertexShaderProgram,
const c8* vertexShaderEntryPointName="main", const c8 *vertexShaderEntryPointName = "main",
E_VERTEX_SHADER_TYPE vsCompileTarget=EVST_VS_1_1, E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
const c8* pixelShaderProgram=0, const c8 *pixelShaderProgram = 0,
const c8* pixelShaderEntryPointName="main", const c8 *pixelShaderEntryPointName = "main",
E_PIXEL_SHADER_TYPE psCompileTarget=EPST_PS_1_1, E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
IShaderConstantSetCallBack* callback=0, IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial=video::EMT_SOLID, E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData=0) s32 userData = 0)
{ {
return addHighLevelShaderMaterial( return addHighLevelShaderMaterial(
vertexShaderProgram, vertexShaderEntryPointName, vertexShaderProgram, vertexShaderEntryPointName,
vsCompileTarget, pixelShaderProgram, vsCompileTarget, pixelShaderProgram,
pixelShaderEntryPointName, psCompileTarget, pixelShaderEntryPointName, psCompileTarget,
0, "main", EGST_GS_4_0, 0, "main", EGST_GS_4_0,
scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
callback, baseMaterial, userData); callback, baseMaterial, userData);
} }
//! convenience function for use with many defaults, without geometry shader //! convenience function for use with many defaults, without geometry shader
@ -115,19 +114,19 @@ public:
type 1.1. type 1.1.
*/ */
s32 addHighLevelShaderMaterial( s32 addHighLevelShaderMaterial(
const c8* vertexShaderProgram, const c8 *vertexShaderProgram,
const c8* pixelShaderProgram=0, const c8 *pixelShaderProgram = 0,
IShaderConstantSetCallBack* callback=0, IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID, E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData=0) s32 userData = 0)
{ {
return addHighLevelShaderMaterial( return addHighLevelShaderMaterial(
vertexShaderProgram, "main", vertexShaderProgram, "main",
EVST_VS_1_1, pixelShaderProgram, EVST_VS_1_1, pixelShaderProgram,
"main", EPST_PS_1_1, "main", EPST_PS_1_1,
0, "main", EGST_GS_4_0, 0, "main", EGST_GS_4_0,
scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
callback, baseMaterial, userData); callback, baseMaterial, userData);
} }
//! convenience function for use with many defaults, with geometry shader //! convenience function for use with many defaults, with geometry shader
@ -135,23 +134,23 @@ public:
type 1.1 and geometry shader 4.0. type 1.1 and geometry shader 4.0.
*/ */
s32 addHighLevelShaderMaterial( s32 addHighLevelShaderMaterial(
const c8* vertexShaderProgram, const c8 *vertexShaderProgram,
const c8* pixelShaderProgram = 0, const c8 *pixelShaderProgram = 0,
const c8* geometryShaderProgram = 0, const c8 *geometryShaderProgram = 0,
scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES, scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP, scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
u32 verticesOut = 0, u32 verticesOut = 0,
IShaderConstantSetCallBack* callback = 0, IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID, E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0 ) s32 userData = 0)
{ {
return addHighLevelShaderMaterial( return addHighLevelShaderMaterial(
vertexShaderProgram, "main", vertexShaderProgram, "main",
EVST_VS_1_1, pixelShaderProgram, EVST_VS_1_1, pixelShaderProgram,
"main", EPST_PS_1_1, "main", EPST_PS_1_1,
geometryShaderProgram, "main", EGST_GS_4_0, geometryShaderProgram, "main", EGST_GS_4_0,
inType, outType, verticesOut, inType, outType, verticesOut,
callback, baseMaterial, userData); callback, baseMaterial, userData);
} }
//! Like addHighLevelShaderMaterial(), but loads from files. //! Like addHighLevelShaderMaterial(), but loads from files.
@ -197,41 +196,41 @@ public:
target is not reachable. The error strings are then printed to the target is not reachable. The error strings are then printed to the
error log and can be caught with a custom event receiver. */ error log and can be caught with a custom event receiver. */
virtual s32 addHighLevelShaderMaterialFromFiles( virtual s32 addHighLevelShaderMaterialFromFiles(
const io::path& vertexShaderProgramFileName, const io::path &vertexShaderProgramFileName,
const c8* vertexShaderEntryPointName, const c8 *vertexShaderEntryPointName,
E_VERTEX_SHADER_TYPE vsCompileTarget, E_VERTEX_SHADER_TYPE vsCompileTarget,
const io::path& pixelShaderProgramFileName, const io::path &pixelShaderProgramFileName,
const c8* pixelShaderEntryPointName, const c8 *pixelShaderEntryPointName,
E_PIXEL_SHADER_TYPE psCompileTarget, E_PIXEL_SHADER_TYPE psCompileTarget,
const io::path& geometryShaderProgramFileName, const io::path &geometryShaderProgramFileName,
const c8* geometryShaderEntryPointName = "main", const c8 *geometryShaderEntryPointName = "main",
E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0, E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES, scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP, scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
u32 verticesOut = 0, u32 verticesOut = 0,
IShaderConstantSetCallBack* callback = 0, IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID, E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0) = 0; s32 userData = 0) = 0;
//! convenience function for use without geometry shaders //! convenience function for use without geometry shaders
s32 addHighLevelShaderMaterialFromFiles( s32 addHighLevelShaderMaterialFromFiles(
const io::path& vertexShaderProgramFileName, const io::path &vertexShaderProgramFileName,
const c8* vertexShaderEntryPointName = "main", const c8 *vertexShaderEntryPointName = "main",
E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1, E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
const io::path& pixelShaderProgramFileName = "", const io::path &pixelShaderProgramFileName = "",
const c8* pixelShaderEntryPointName = "main", const c8 *pixelShaderEntryPointName = "main",
E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1, E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
IShaderConstantSetCallBack* callback = 0, IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID, E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0) s32 userData = 0)
{ {
return addHighLevelShaderMaterialFromFiles( return addHighLevelShaderMaterialFromFiles(
vertexShaderProgramFileName, vertexShaderEntryPointName, vertexShaderProgramFileName, vertexShaderEntryPointName,
vsCompileTarget, pixelShaderProgramFileName, vsCompileTarget, pixelShaderProgramFileName,
pixelShaderEntryPointName, psCompileTarget, pixelShaderEntryPointName, psCompileTarget,
"", "main", EGST_GS_4_0, "", "main", EGST_GS_4_0,
scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
callback, baseMaterial, userData); callback, baseMaterial, userData);
} }
//! convenience function for use with many defaults, without geometry shader //! convenience function for use with many defaults, without geometry shader
@ -239,19 +238,19 @@ public:
type 1.1. type 1.1.
*/ */
s32 addHighLevelShaderMaterialFromFiles( s32 addHighLevelShaderMaterialFromFiles(
const io::path& vertexShaderProgramFileName, const io::path &vertexShaderProgramFileName,
const io::path& pixelShaderProgramFileName = "", const io::path &pixelShaderProgramFileName = "",
IShaderConstantSetCallBack* callback = 0, IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID, E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0 ) s32 userData = 0)
{ {
return addHighLevelShaderMaterialFromFiles( return addHighLevelShaderMaterialFromFiles(
vertexShaderProgramFileName, "main", vertexShaderProgramFileName, "main",
EVST_VS_1_1, pixelShaderProgramFileName, EVST_VS_1_1, pixelShaderProgramFileName,
"main", EPST_PS_1_1, "main", EPST_PS_1_1,
"", "main", EGST_GS_4_0, "", "main", EGST_GS_4_0,
scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
callback, baseMaterial, userData); callback, baseMaterial, userData);
} }
//! convenience function for use with many defaults, with geometry shader //! convenience function for use with many defaults, with geometry shader
@ -259,23 +258,23 @@ public:
type 1.1 and geometry shader 4.0. type 1.1 and geometry shader 4.0.
*/ */
s32 addHighLevelShaderMaterialFromFiles( s32 addHighLevelShaderMaterialFromFiles(
const io::path& vertexShaderProgramFileName, const io::path &vertexShaderProgramFileName,
const io::path& pixelShaderProgramFileName = "", const io::path &pixelShaderProgramFileName = "",
const io::path& geometryShaderProgramFileName = "", const io::path &geometryShaderProgramFileName = "",
scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES, scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP, scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
u32 verticesOut = 0, u32 verticesOut = 0,
IShaderConstantSetCallBack* callback = 0, IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID, E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0 ) s32 userData = 0)
{ {
return addHighLevelShaderMaterialFromFiles( return addHighLevelShaderMaterialFromFiles(
vertexShaderProgramFileName, "main", vertexShaderProgramFileName, "main",
EVST_VS_1_1, pixelShaderProgramFileName, EVST_VS_1_1, pixelShaderProgramFileName,
"main", EPST_PS_1_1, "main", EPST_PS_1_1,
geometryShaderProgramFileName, "main", EGST_GS_4_0, geometryShaderProgramFileName, "main", EGST_GS_4_0,
inType, outType, verticesOut, inType, outType, verticesOut,
callback, baseMaterial, userData); callback, baseMaterial, userData);
} }
//! Like addHighLevelShaderMaterial(), but loads from files. //! Like addHighLevelShaderMaterial(), but loads from files.
@ -319,41 +318,41 @@ public:
compile target is not reachable. The error strings are then printed to compile target is not reachable. The error strings are then printed to
the error log and can be caught with a custom event receiver. */ the error log and can be caught with a custom event receiver. */
virtual s32 addHighLevelShaderMaterialFromFiles( virtual s32 addHighLevelShaderMaterialFromFiles(
io::IReadFile* vertexShaderProgram, io::IReadFile *vertexShaderProgram,
const c8* vertexShaderEntryPointName, const c8 *vertexShaderEntryPointName,
E_VERTEX_SHADER_TYPE vsCompileTarget, E_VERTEX_SHADER_TYPE vsCompileTarget,
io::IReadFile* pixelShaderProgram, io::IReadFile *pixelShaderProgram,
const c8* pixelShaderEntryPointName, const c8 *pixelShaderEntryPointName,
E_PIXEL_SHADER_TYPE psCompileTarget, E_PIXEL_SHADER_TYPE psCompileTarget,
io::IReadFile* geometryShaderProgram, io::IReadFile *geometryShaderProgram,
const c8* geometryShaderEntryPointName = "main", const c8 *geometryShaderEntryPointName = "main",
E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0, E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES, scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP, scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
u32 verticesOut = 0, u32 verticesOut = 0,
IShaderConstantSetCallBack* callback = 0, IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID, E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0) = 0; s32 userData = 0) = 0;
//! convenience function for use without geometry shaders //! convenience function for use without geometry shaders
s32 addHighLevelShaderMaterialFromFiles( s32 addHighLevelShaderMaterialFromFiles(
io::IReadFile* vertexShaderProgram, io::IReadFile *vertexShaderProgram,
const c8* vertexShaderEntryPointName = "main", const c8 *vertexShaderEntryPointName = "main",
E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1, E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
io::IReadFile* pixelShaderProgram = 0, io::IReadFile *pixelShaderProgram = 0,
const c8* pixelShaderEntryPointName = "main", const c8 *pixelShaderEntryPointName = "main",
E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1, E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
IShaderConstantSetCallBack* callback = 0, IShaderConstantSetCallBack *callback = 0,
E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID, E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
s32 userData = 0) s32 userData = 0)
{ {
return addHighLevelShaderMaterialFromFiles( return addHighLevelShaderMaterialFromFiles(
vertexShaderProgram, vertexShaderEntryPointName, vertexShaderProgram, vertexShaderEntryPointName,
vsCompileTarget, pixelShaderProgram, vsCompileTarget, pixelShaderProgram,
pixelShaderEntryPointName, psCompileTarget, pixelShaderEntryPointName, psCompileTarget,
0, "main", EGST_GS_4_0, 0, "main", EGST_GS_4_0,
scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0,
callback, baseMaterial, userData); callback, baseMaterial, userData);
} }
//! Delete a shader material and associated data. //! Delete a shader material and associated data.
@ -366,6 +365,5 @@ public:
virtual void deleteShaderMaterial(s32 material) = 0; virtual void deleteShaderMaterial(s32 material) = 0;
}; };
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

413
include/IGUIButton.h
View File

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

52
include/IGUICheckBox.h
View File

@ -11,39 +11,37 @@ namespace irr
namespace gui namespace gui
{ {
//! GUI Check box interface. //! GUI Check box interface.
/** \par This element can create the following events of type EGUI_EVENT_TYPE: /** \par This element can create the following events of type EGUI_EVENT_TYPE:
\li EGET_CHECKBOX_CHANGED \li EGET_CHECKBOX_CHANGED
*/ */
class IGUICheckBox : public IGUIElement class IGUICheckBox : public IGUIElement
{ {
public: public:
//! constructor
IGUICheckBox(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_CHECK_BOX, environment, parent, id, rectangle) {}
//! constructor //! Set if box is checked.
IGUICheckBox(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle) virtual void setChecked(bool checked) = 0;
: IGUIElement(EGUIET_CHECK_BOX, environment, parent, id, rectangle) {}
//! Set if box is checked. //! Returns true if box is checked.
virtual void setChecked(bool checked) = 0; virtual bool isChecked() const = 0;
//! Returns true if box is checked. //! Sets whether to draw the background
virtual bool isChecked() const = 0; virtual void setDrawBackground(bool draw) = 0;
//! Sets whether to draw the background //! Checks if background drawing is enabled
virtual void setDrawBackground(bool draw) = 0; /** \return true if background drawing is enabled, false otherwise */
virtual bool isDrawBackgroundEnabled() const = 0;
//! Checks if background drawing is enabled //! Sets whether to draw the border
/** \return true if background drawing is enabled, false otherwise */ virtual void setDrawBorder(bool draw) = 0;
virtual bool isDrawBackgroundEnabled() const = 0;
//! Sets whether to draw the border //! Checks if border drawing is enabled
virtual void setDrawBorder(bool draw) = 0; /** \return true if border drawing is enabled, false otherwise */
virtual bool isDrawBorderEnabled() const = 0;
//! Checks if border drawing is enabled };
/** \return true if border drawing is enabled, false otherwise */
virtual bool isDrawBorderEnabled() const = 0;
};
} // end namespace gui } // end namespace gui
} // end namespace irr } // end namespace irr

88
include/IGUIComboBox.h
View File

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

216
include/IGUIEditBox.h
View File

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

409
include/IGUIElement.h
View File

@ -25,30 +25,28 @@ namespace gui
class IGUIElement : virtual public IReferenceCounted, public IEventReceiver class IGUIElement : virtual public IReferenceCounted, public IEventReceiver
{ {
public: public:
//! Constructor //! Constructor
IGUIElement(EGUI_ELEMENT_TYPE type, IGUIEnvironment* environment, IGUIElement* parent, IGUIElement(EGUI_ELEMENT_TYPE type, IGUIEnvironment *environment, IGUIElement *parent,
s32 id, const core::rect<s32>& rectangle) s32 id, const core::rect<s32> &rectangle) :
: Parent(0), RelativeRect(rectangle), AbsoluteRect(rectangle), Parent(0),
AbsoluteClippingRect(rectangle), DesiredRect(rectangle), RelativeRect(rectangle), AbsoluteRect(rectangle),
MaxSize(0,0), MinSize(1,1), IsVisible(true), IsEnabled(true), AbsoluteClippingRect(rectangle), DesiredRect(rectangle),
IsSubElement(false), NoClip(false), ID(id), IsTabStop(false), TabOrder(-1), IsTabGroup(false), MaxSize(0, 0), MinSize(1, 1), IsVisible(true), IsEnabled(true),
AlignLeft(EGUIA_UPPERLEFT), AlignRight(EGUIA_UPPERLEFT), AlignTop(EGUIA_UPPERLEFT), AlignBottom(EGUIA_UPPERLEFT), IsSubElement(false), NoClip(false), ID(id), IsTabStop(false), TabOrder(-1), IsTabGroup(false),
Environment(environment), Type(type) AlignLeft(EGUIA_UPPERLEFT), AlignRight(EGUIA_UPPERLEFT), AlignTop(EGUIA_UPPERLEFT), AlignBottom(EGUIA_UPPERLEFT),
Environment(environment), Type(type)
{ {
#ifdef _DEBUG #ifdef _DEBUG
setDebugName("IGUIElement"); setDebugName("IGUIElement");
#endif #endif
// if we were given a parent to attach to // if we were given a parent to attach to
if (parent) if (parent) {
{
parent->addChildToEnd(this); parent->addChildToEnd(this);
recalculateAbsolutePosition(true); recalculateAbsolutePosition(true);
} }
} }
//! Destructor //! Destructor
virtual ~IGUIElement() virtual ~IGUIElement()
{ {
@ -58,9 +56,8 @@ public:
} }
} }
//! Returns parent of this element. //! Returns parent of this element.
IGUIElement* getParent() const IGUIElement *getParent() const
{ {
return Parent; return Parent;
} }
@ -71,22 +68,20 @@ public:
return RelativeRect; return RelativeRect;
} }
//! Sets the relative rectangle of this element. //! Sets the relative rectangle of this element.
/** \param r The absolute position to set */ /** \param r The absolute position to set */
void setRelativePosition(const core::rect<s32>& r) void setRelativePosition(const core::rect<s32> &r)
{ {
if (Parent) if (Parent) {
{ const core::rect<s32> &r2 = Parent->getAbsolutePosition();
const core::rect<s32>& r2 = Parent->getAbsolutePosition();
core::dimension2df d((f32)(r2.getSize().Width), (f32)(r2.getSize().Height)); core::dimension2df d((f32)(r2.getSize().Width), (f32)(r2.getSize().Height));
if (AlignLeft == EGUIA_SCALE) if (AlignLeft == EGUIA_SCALE)
ScaleRect.UpperLeftCorner.X = (f32)r.UpperLeftCorner.X / d.Width; ScaleRect.UpperLeftCorner.X = (f32)r.UpperLeftCorner.X / d.Width;
if (AlignRight == EGUIA_SCALE) if (AlignRight == EGUIA_SCALE)
ScaleRect.LowerRightCorner.X = (f32)r.LowerRightCorner.X / d.Width; ScaleRect.LowerRightCorner.X = (f32)r.LowerRightCorner.X / d.Width;
if (AlignTop == EGUIA_SCALE) if (AlignTop == EGUIA_SCALE)
ScaleRect.UpperLeftCorner.Y = (f32)r.UpperLeftCorner.Y / d.Height; ScaleRect.UpperLeftCorner.Y = (f32)r.UpperLeftCorner.Y / d.Height;
if (AlignBottom == EGUIA_SCALE) if (AlignBottom == EGUIA_SCALE)
ScaleRect.LowerRightCorner.Y = (f32)r.LowerRightCorner.Y / d.Height; ScaleRect.LowerRightCorner.Y = (f32)r.LowerRightCorner.Y / d.Height;
@ -98,53 +93,49 @@ public:
//! Sets the relative rectangle of this element, maintaining its current width and height //! Sets the relative rectangle of this element, maintaining its current width and height
/** \param position The new relative position to set. Width and height will not be changed. */ /** \param position The new relative position to set. Width and height will not be changed. */
void setRelativePosition(const core::position2di & position) void setRelativePosition(const core::position2di &position)
{ {
const core::dimension2di mySize = RelativeRect.getSize(); const core::dimension2di mySize = RelativeRect.getSize();
const core::rect<s32> rectangle(position.X, position.Y, const core::rect<s32> rectangle(position.X, position.Y,
position.X + mySize.Width, position.Y + mySize.Height); position.X + mySize.Width, position.Y + mySize.Height);
setRelativePosition(rectangle); setRelativePosition(rectangle);
} }
//! Sets the relative rectangle of this element as a proportion of its parent's area. //! Sets the relative rectangle of this element as a proportion of its parent's area.
/** \note This method used to be 'void setRelativePosition(const core::rect<f32>& r)' /** \note This method used to be 'void setRelativePosition(const core::rect<f32>& r)'
\param r The rectangle to set, interpreted as a proportion of the parent's area. \param r The rectangle to set, interpreted as a proportion of the parent's area.
Meaningful values are in the range [0...1], unless you intend this element to spill Meaningful values are in the range [0...1], unless you intend this element to spill
outside its parent. */ outside its parent. */
void setRelativePositionProportional(const core::rect<f32>& r) void setRelativePositionProportional(const core::rect<f32> &r)
{ {
if (!Parent) if (!Parent)
return; return;
const core::dimension2di& d = Parent->getAbsolutePosition().getSize(); const core::dimension2di &d = Parent->getAbsolutePosition().getSize();
DesiredRect = core::rect<s32>( DesiredRect = core::rect<s32>(
core::floor32((f32)d.Width * r.UpperLeftCorner.X), core::floor32((f32)d.Width * r.UpperLeftCorner.X),
core::floor32((f32)d.Height * r.UpperLeftCorner.Y), core::floor32((f32)d.Height * r.UpperLeftCorner.Y),
core::floor32((f32)d.Width * r.LowerRightCorner.X), core::floor32((f32)d.Width * r.LowerRightCorner.X),
core::floor32((f32)d.Height * r.LowerRightCorner.Y)); core::floor32((f32)d.Height * r.LowerRightCorner.Y));
ScaleRect = r; ScaleRect = r;
updateAbsolutePosition(); updateAbsolutePosition();
} }
//! Gets the absolute rectangle of this element //! Gets the absolute rectangle of this element
core::rect<s32> getAbsolutePosition() const core::rect<s32> getAbsolutePosition() const
{ {
return AbsoluteRect; return AbsoluteRect;
} }
//! Returns the visible area of the element. //! Returns the visible area of the element.
core::rect<s32> getAbsoluteClippingRect() const core::rect<s32> getAbsoluteClippingRect() const
{ {
return AbsoluteClippingRect; return AbsoluteClippingRect;
} }
//! Sets whether the element will ignore its parent's clipping rectangle //! Sets whether the element will ignore its parent's clipping rectangle
/** \param noClip If true, the element will not be clipped by its parent's clipping rectangle. */ /** \param noClip If true, the element will not be clipped by its parent's clipping rectangle. */
void setNotClipped(bool noClip) void setNotClipped(bool noClip)
@ -153,7 +144,6 @@ public:
updateAbsolutePosition(); updateAbsolutePosition();
} }
//! Gets whether the element will ignore its parent's clipping rectangle //! Gets whether the element will ignore its parent's clipping rectangle
/** \return true if the element is not clipped by its parent's clipping rectangle. */ /** \return true if the element is not clipped by its parent's clipping rectangle. */
bool isNotClipped() const bool isNotClipped() const
@ -161,7 +151,6 @@ public:
return NoClip; return NoClip;
} }
//! Sets the maximum size allowed for this element //! Sets the maximum size allowed for this element
/** If set to 0,0, there is no maximum size */ /** If set to 0,0, there is no maximum size */
void setMaxSize(core::dimension2du size) void setMaxSize(core::dimension2du size)
@ -170,7 +159,6 @@ public:
updateAbsolutePosition(); updateAbsolutePosition();
} }
//! Sets the minimum size allowed for this element //! Sets the minimum size allowed for this element
void setMinSize(core::dimension2du size) void setMinSize(core::dimension2du size)
{ {
@ -182,7 +170,6 @@ public:
updateAbsolutePosition(); updateAbsolutePosition();
} }
//! The alignment defines how the borders of this element will be positioned when the parent element is resized. //! The alignment defines how the borders of this element will be positioned when the parent element is resized.
void setAlignment(EGUI_ALIGNMENT left, EGUI_ALIGNMENT right, EGUI_ALIGNMENT top, EGUI_ALIGNMENT bottom) void setAlignment(EGUI_ALIGNMENT left, EGUI_ALIGNMENT right, EGUI_ALIGNMENT top, EGUI_ALIGNMENT bottom)
{ {
@ -191,17 +178,16 @@ public:
AlignTop = top; AlignTop = top;
AlignBottom = bottom; AlignBottom = bottom;
if (Parent) if (Parent) {
{
core::rect<s32> r(Parent->getAbsolutePosition()); core::rect<s32> r(Parent->getAbsolutePosition());
core::dimension2df d((f32)r.getSize().Width, (f32)r.getSize().Height); core::dimension2df d((f32)r.getSize().Width, (f32)r.getSize().Height);
if (AlignLeft == EGUIA_SCALE) if (AlignLeft == EGUIA_SCALE)
ScaleRect.UpperLeftCorner.X = (f32)DesiredRect.UpperLeftCorner.X / d.Width; ScaleRect.UpperLeftCorner.X = (f32)DesiredRect.UpperLeftCorner.X / d.Width;
if (AlignRight == EGUIA_SCALE) if (AlignRight == EGUIA_SCALE)
ScaleRect.LowerRightCorner.X = (f32)DesiredRect.LowerRightCorner.X / d.Width; ScaleRect.LowerRightCorner.X = (f32)DesiredRect.LowerRightCorner.X / d.Width;
if (AlignTop == EGUIA_SCALE) if (AlignTop == EGUIA_SCALE)
ScaleRect.UpperLeftCorner.Y = (f32)DesiredRect.UpperLeftCorner.Y / d.Height; ScaleRect.UpperLeftCorner.Y = (f32)DesiredRect.UpperLeftCorner.Y / d.Height;
if (AlignBottom == EGUIA_SCALE) if (AlignBottom == EGUIA_SCALE)
ScaleRect.LowerRightCorner.Y = (f32)DesiredRect.LowerRightCorner.Y / d.Height; ScaleRect.LowerRightCorner.Y = (f32)DesiredRect.LowerRightCorner.Y / d.Height;
@ -238,13 +224,11 @@ public:
recalculateAbsolutePosition(false); recalculateAbsolutePosition(false);
// update all children // update all children
for (auto child : Children) for (auto child : Children) {
{
child->updateAbsolutePosition(); child->updateAbsolutePosition();
} }
} }
//! Returns the topmost GUI element at the specific position. //! Returns the topmost GUI element at the specific position.
/** /**
This will check this GUI element and all of its descendants, so it This will check this GUI element and all of its descendants, so it
@ -257,18 +241,16 @@ public:
\return The topmost GUI element at that point, or 0 if there are \return The topmost GUI element at that point, or 0 if there are
no candidate elements at this point. no candidate elements at this point.
*/ */
virtual IGUIElement* getElementFromPoint(const core::position2d<s32>& point) virtual IGUIElement *getElementFromPoint(const core::position2d<s32> &point)
{ {
IGUIElement* target = 0; IGUIElement *target = 0;
if (isVisible()) if (isVisible()) {
{
// we have to search from back to front, because later children // we have to search from back to front, because later children
// might be drawn over the top of earlier ones. // might be drawn over the top of earlier ones.
auto it = Children.rbegin(); auto it = Children.rbegin();
auto ie = Children.rend(); auto ie = Children.rend();
while (it != ie) while (it != ie) {
{
target = (*it)->getElementFromPoint(point); target = (*it)->getElementFromPoint(point);
if (target) if (target)
return target; return target;
@ -283,27 +265,24 @@ public:
return target; return target;
} }
//! Returns true if a point is within this element. //! Returns true if a point is within this element.
/** Elements with a shape other than a rectangle should override this method */ /** Elements with a shape other than a rectangle should override this method */
virtual bool isPointInside(const core::position2d<s32>& point) const virtual bool isPointInside(const core::position2d<s32> &point) const
{ {
return AbsoluteClippingRect.isPointInside(point); return AbsoluteClippingRect.isPointInside(point);
} }
//! Adds a GUI element as new child of this element. //! Adds a GUI element as new child of this element.
virtual void addChild(IGUIElement* child) virtual void addChild(IGUIElement *child)
{ {
if ( child && child != this ) if (child && child != this) {
{
addChildToEnd(child); addChildToEnd(child);
child->updateAbsolutePosition(); child->updateAbsolutePosition();
} }
} }
//! Removes a child. //! Removes a child.
virtual void removeChild(IGUIElement* child) virtual void removeChild(IGUIElement *child)
{ {
assert(child->Parent == this); assert(child->Parent == this);
Children.erase(child->ParentPos); Children.erase(child->ParentPos);
@ -312,7 +291,8 @@ public:
} }
//! Removes all children. //! Removes all children.
virtual void removeAllChildren() { virtual void removeAllChildren()
{
while (!Children.empty()) { while (!Children.empty()) {
auto child = Children.back(); auto child = Children.back();
child->remove(); child->remove();
@ -326,36 +306,30 @@ public:
Parent->removeChild(this); Parent->removeChild(this);
} }
//! Draws the element and its children. //! Draws the element and its children.
virtual void draw() virtual void draw()
{ {
if ( isVisible() ) if (isVisible()) {
{
for (auto child : Children) for (auto child : Children)
child->draw(); child->draw();
} }
} }
//! animate the element and its children. //! animate the element and its children.
virtual void OnPostRender(u32 timeMs) virtual void OnPostRender(u32 timeMs)
{ {
if ( isVisible() ) if (isVisible()) {
{
for (auto child : Children) for (auto child : Children)
child->OnPostRender( timeMs ); child->OnPostRender(timeMs);
} }
} }
//! Moves this element. //! Moves this element.
virtual void move(core::position2d<s32> absoluteMovement) virtual void move(core::position2d<s32> absoluteMovement)
{ {
setRelativePosition(DesiredRect + absoluteMovement); setRelativePosition(DesiredRect + absoluteMovement);
} }
//! Returns true if element is visible. //! Returns true if element is visible.
virtual bool isVisible() const virtual bool isVisible() const
{ {
@ -367,10 +341,10 @@ public:
false if this or any parent element is invisible. */ false if this or any parent element is invisible. */
virtual bool isTrulyVisible() const virtual bool isTrulyVisible() const
{ {
if(!IsVisible) if (!IsVisible)
return false; return false;
if(!Parent) if (!Parent)
return true; return true;
return Parent->isTrulyVisible(); return Parent->isTrulyVisible();
@ -382,14 +356,12 @@ public:
IsVisible = visible; IsVisible = visible;
} }
//! Returns true if this element was created as part of its parent control //! Returns true if this element was created as part of its parent control
virtual bool isSubElement() const virtual bool isSubElement() const
{ {
return IsSubElement; return IsSubElement;
} }
//! Sets whether this control was created as part of its parent. //! Sets whether this control was created as part of its parent.
/** For example, it is true when a scrollbar is part of a listbox. /** For example, it is true when a scrollbar is part of a listbox.
SubElements are not saved to disk when calling guiEnvironment->saveGUI() */ SubElements are not saved to disk when calling guiEnvironment->saveGUI() */
@ -398,7 +370,6 @@ public:
IsSubElement = subElement; IsSubElement = subElement;
} }
//! If set to true, the focus will visit this element when using the tab key to cycle through elements. //! If set to true, the focus will visit this element when using the tab key to cycle through elements.
/** If this element is a tab group (see isTabGroup/setTabGroup) then /** If this element is a tab group (see isTabGroup/setTabGroup) then
ctrl+tab will be used instead. */ ctrl+tab will be used instead. */
@ -407,51 +378,43 @@ public:
IsTabStop = enable; IsTabStop = enable;
} }
//! Returns true if this element can be focused by navigating with the tab key //! Returns true if this element can be focused by navigating with the tab key
bool isTabStop() const bool isTabStop() const
{ {
return IsTabStop; return IsTabStop;
} }
//! Sets the priority of focus when using the tab key to navigate between a group of elements. //! Sets the priority of focus when using the tab key to navigate between a group of elements.
/** See setTabGroup, isTabGroup and getTabGroup for information on tab groups. /** See setTabGroup, isTabGroup and getTabGroup for information on tab groups.
Elements with a lower number are focused first */ Elements with a lower number are focused first */
void setTabOrder(s32 index) void setTabOrder(s32 index)
{ {
// negative = autonumber // negative = autonumber
if (index < 0) if (index < 0) {
{
TabOrder = 0; TabOrder = 0;
IGUIElement *el = getTabGroup(); IGUIElement *el = getTabGroup();
while (IsTabGroup && el && el->Parent) while (IsTabGroup && el && el->Parent)
el = el->Parent; el = el->Parent;
IGUIElement *first=0, *closest=0; IGUIElement *first = 0, *closest = 0;
if (el) if (el) {
{
// find the highest element number // find the highest element number
el->getNextElement(-1, true, IsTabGroup, first, closest, true, true); el->getNextElement(-1, true, IsTabGroup, first, closest, true, true);
if (first) if (first) {
{
TabOrder = first->getTabOrder() + 1; TabOrder = first->getTabOrder() + 1;
} }
} }
} } else
else
TabOrder = index; TabOrder = index;
} }
//! Returns the number in the tab order sequence //! Returns the number in the tab order sequence
s32 getTabOrder() const s32 getTabOrder() const
{ {
return TabOrder; return TabOrder;
} }
//! Sets whether this element is a container for a group of elements which can be navigated using the tab key. //! Sets whether this element is a container for a group of elements which can be navigated using the tab key.
/** For example, windows are tab groups. /** For example, windows are tab groups.
Groups can be navigated using ctrl+tab, providing isTabStop is true. */ Groups can be navigated using ctrl+tab, providing isTabStop is true. */
@ -460,18 +423,16 @@ public:
IsTabGroup = isGroup; IsTabGroup = isGroup;
} }
//! Returns true if this element is a tab group. //! Returns true if this element is a tab group.
bool isTabGroup() const bool isTabGroup() const
{ {
return IsTabGroup; return IsTabGroup;
} }
//! Returns the container element which holds all elements in this element's tab group. //! Returns the container element which holds all elements in this element's tab group.
IGUIElement* getTabGroup() IGUIElement *getTabGroup()
{ {
IGUIElement *ret=this; IGUIElement *ret = this;
while (ret && !ret->isTabGroup()) while (ret && !ret->isTabGroup())
ret = ret->getParent(); ret = ret->getParent();
@ -479,7 +440,6 @@ public:
return ret; return ret;
} }
//! Returns true if element is enabled //! Returns true if element is enabled
/** Currently elements do _not_ care about parent-states. /** Currently elements do _not_ care about parent-states.
So if you want to affect children you have to enable/disable them all. So if you want to affect children you have to enable/disable them all.
@ -487,72 +447,63 @@ public:
*/ */
virtual bool isEnabled() const virtual bool isEnabled() const
{ {
if ( isSubElement() && IsEnabled && getParent() ) if (isSubElement() && IsEnabled && getParent())
return getParent()->isEnabled(); return getParent()->isEnabled();
return IsEnabled; return IsEnabled;
} }
//! Sets the enabled state of this element. //! Sets the enabled state of this element.
virtual void setEnabled(bool enabled) virtual void setEnabled(bool enabled)
{ {
IsEnabled = enabled; IsEnabled = enabled;
} }
//! Sets the new caption of this element. //! Sets the new caption of this element.
virtual void setText(const wchar_t* text) virtual void setText(const wchar_t *text)
{ {
Text = text; Text = text;
} }
//! Returns caption of this element. //! Returns caption of this element.
virtual const wchar_t* getText() const virtual const wchar_t *getText() const
{ {
return Text.c_str(); return Text.c_str();
} }
//! Sets the new caption of this element. //! Sets the new caption of this element.
virtual void setToolTipText(const wchar_t* text) virtual void setToolTipText(const wchar_t *text)
{ {
ToolTipText = text; ToolTipText = text;
} }
//! Returns caption of this element. //! Returns caption of this element.
virtual const core::stringw& getToolTipText() const virtual const core::stringw &getToolTipText() const
{ {
return ToolTipText; return ToolTipText;
} }
//! Returns id. Can be used to identify the element. //! Returns id. Can be used to identify the element.
virtual s32 getID() const virtual s32 getID() const
{ {
return ID; return ID;
} }
//! Sets the id of this element //! Sets the id of this element
virtual void setID(s32 id) virtual void setID(s32 id)
{ {
ID = id; ID = id;
} }
//! Called if an event happened. //! Called if an event happened.
bool OnEvent(const SEvent& event) override bool OnEvent(const SEvent &event) override
{ {
return Parent ? Parent->OnEvent(event) : false; return Parent ? Parent->OnEvent(event) : false;
} }
//! Brings a child to front //! Brings a child to front
/** \return True if successful, false if not. */ /** \return True if successful, false if not. */
virtual bool bringToFront(IGUIElement* child) virtual bool bringToFront(IGUIElement *child)
{ {
if (child->Parent != this) if (child->Parent != this)
return false; return false;
@ -563,10 +514,9 @@ public:
return true; return true;
} }
//! Moves a child to the back, so it's siblings are drawn on top of it //! Moves a child to the back, so it's siblings are drawn on top of it
/** \return True if successful, false if not. */ /** \return True if successful, false if not. */
virtual bool sendToBack(IGUIElement* child) virtual bool sendToBack(IGUIElement *child)
{ {
if (child->Parent != this) if (child->Parent != this)
return false; return false;
@ -578,12 +528,11 @@ public:
} }
//! Returns list with children of this element //! Returns list with children of this element
virtual const std::list<IGUIElement*>& getChildren() const virtual const std::list<IGUIElement *> &getChildren() const
{ {
return Children; return Children;
} }
//! Finds the first element with the given id. //! Finds the first element with the given id.
/** \param id: Id to search for. /** \param id: Id to search for.
\param searchchildren: Set this to true, if also children of this \param searchchildren: Set this to true, if also children of this
@ -591,12 +540,11 @@ public:
should be searched too. should be searched too.
\return Returns the first element with the given id. If no element \return Returns the first element with the given id. If no element
with this id was found, 0 is returned. */ with this id was found, 0 is returned. */
virtual IGUIElement* getElementFromId(s32 id, bool searchchildren=false) const virtual IGUIElement *getElementFromId(s32 id, bool searchchildren = false) const
{ {
IGUIElement* e = 0; IGUIElement *e = 0;
for (auto child : Children) for (auto child : Children) {
{
if (child->getID() == id) if (child->getID() == id)
return child; return child;
@ -610,25 +558,21 @@ public:
return e; return e;
} }
//! returns true if the given element is a child of this one. //! returns true if the given element is a child of this one.
//! \param child: The child element to check //! \param child: The child element to check
bool isMyChild(IGUIElement* child) const bool isMyChild(IGUIElement *child) const
{ {
if (!child) if (!child)
return false; return false;
do do {
{
if (child->Parent) if (child->Parent)
child = child->Parent; child = child->Parent;
} while (child->Parent && child != this); } while (child->Parent && child != this);
return child == this; return child == this;
} }
//! searches elements to find the closest next element to tab to //! searches elements to find the closest next element to tab to
/** \param startOrder: The TabOrder of the current element, -1 if none /** \param startOrder: The TabOrder of the current element, -1 if none
\param reverse: true if searching for a lower number \param reverse: true if searching for a lower number
@ -639,74 +583,58 @@ public:
\param includeDisabled: includes disabled elements in the search (default=false) \param includeDisabled: includes disabled elements in the search (default=false)
\return true if successfully found an element, false to continue searching/fail */ \return true if successfully found an element, false to continue searching/fail */
bool getNextElement(s32 startOrder, bool reverse, bool group, bool getNextElement(s32 startOrder, bool reverse, bool group,
IGUIElement*& first, IGUIElement*& closest, bool includeInvisible=false, IGUIElement *&first, IGUIElement *&closest, bool includeInvisible = false,
bool includeDisabled=false) const bool includeDisabled = false) const
{ {
// we'll stop searching if we find this number // we'll stop searching if we find this number
s32 wanted = startOrder + ( reverse ? -1 : 1 ); s32 wanted = startOrder + (reverse ? -1 : 1);
if (wanted==-2) if (wanted == -2)
wanted = 1073741824; // maximum s32 wanted = 1073741824; // maximum s32
auto it = Children.begin(); auto it = Children.begin();
s32 closestOrder, currentOrder; s32 closestOrder, currentOrder;
while(it != Children.end()) while (it != Children.end()) {
{
// ignore invisible elements and their children // ignore invisible elements and their children
if ( ( (*it)->isVisible() || includeInvisible ) && if (((*it)->isVisible() || includeInvisible) &&
(group == true || (*it)->isTabGroup() == false) ) (group == true || (*it)->isTabGroup() == false)) {
{
// ignore disabled, but children are checked (disabled is currently per element ignoring parent states) // ignore disabled, but children are checked (disabled is currently per element ignoring parent states)
if ( (*it)->isEnabled() || includeDisabled ) if ((*it)->isEnabled() || includeDisabled) {
{
// only check tab stops and those with the same group status // only check tab stops and those with the same group status
if ((*it)->isTabStop() && ((*it)->isTabGroup() == group)) if ((*it)->isTabStop() && ((*it)->isTabGroup() == group)) {
{
currentOrder = (*it)->getTabOrder(); currentOrder = (*it)->getTabOrder();
// is this what we're looking for? // is this what we're looking for?
if (currentOrder == wanted) if (currentOrder == wanted) {
{
closest = *it; closest = *it;
return true; return true;
} }
// is it closer than the current closest? // is it closer than the current closest?
if (closest) if (closest) {
{
closestOrder = closest->getTabOrder(); closestOrder = closest->getTabOrder();
if ( ( reverse && currentOrder > closestOrder && currentOrder < startOrder) if ((reverse && currentOrder > closestOrder && currentOrder < startOrder) || (!reverse && currentOrder < closestOrder && currentOrder > startOrder)) {
||(!reverse && currentOrder < closestOrder && currentOrder > startOrder))
{
closest = *it; closest = *it;
} }
} } else if ((reverse && currentOrder < startOrder) || (!reverse && currentOrder > startOrder)) {
else
if ( (reverse && currentOrder < startOrder) || (!reverse && currentOrder > startOrder) )
{
closest = *it; closest = *it;
} }
// is it before the current first? // is it before the current first?
if (first) if (first) {
{
closestOrder = first->getTabOrder(); closestOrder = first->getTabOrder();
if ( (reverse && closestOrder < currentOrder) || (!reverse && closestOrder > currentOrder) ) if ((reverse && closestOrder < currentOrder) || (!reverse && closestOrder > currentOrder)) {
{
first = *it; first = *it;
} }
} } else {
else
{
first = *it; first = *it;
} }
} }
} }
// search within children // search within children
if ((*it)->getNextElement(startOrder, reverse, group, first, closest, includeInvisible, includeDisabled)) if ((*it)->getNextElement(startOrder, reverse, group, first, closest, includeInvisible, includeDisabled)) {
{
return true; return true;
} }
} }
@ -715,7 +643,6 @@ public:
return false; return false;
} }
//! Returns the type of the gui element. //! Returns the type of the gui element.
/** This is needed for the .NET wrapper but will be used /** This is needed for the .NET wrapper but will be used
later for serializing and deserializing. later for serializing and deserializing.
@ -740,52 +667,46 @@ public:
return type == Type; return type == Type;
} }
//! Returns the type name of the gui element. //! Returns the type name of the gui element.
/** This is needed serializing elements. */ /** This is needed serializing elements. */
virtual const c8* getTypeName() const virtual const c8 *getTypeName() const
{ {
return GUIElementTypeNames[Type]; return GUIElementTypeNames[Type];
} }
//! Returns the name of the element. //! Returns the name of the element.
/** \return Name as character string. */ /** \return Name as character string. */
virtual const c8* getName() const virtual const c8 *getName() const
{ {
return Name.c_str(); return Name.c_str();
} }
//! Sets the name of the element. //! Sets the name of the element.
/** \param name New name of the gui element. */ /** \param name New name of the gui element. */
virtual void setName(const c8* name) virtual void setName(const c8 *name)
{ {
Name = name; Name = name;
} }
//! Sets the name of the element. //! Sets the name of the element.
/** \param name New name of the gui element. */ /** \param name New name of the gui element. */
virtual void setName(const core::stringc& name) virtual void setName(const core::stringc &name)
{ {
Name = name; Name = name;
} }
//! Returns whether the element takes input from the IME //! Returns whether the element takes input from the IME
virtual bool acceptsIME() virtual bool acceptsIME()
{ {
return false; return false;
} }
protected: protected:
// not virtual because needed in constructor // not virtual because needed in constructor
void addChildToEnd(IGUIElement* child) void addChildToEnd(IGUIElement *child)
{ {
if (child) if (child) {
{ child->grab(); // prevent destruction when removed
child->grab(); // prevent destruction when removed
child->remove(); // remove from old parent child->remove(); // remove from old parent
child->LastParentRect = getAbsolutePosition(); child->LastParentRect = getAbsolutePosition();
child->Parent = this; child->Parent = this;
@ -794,8 +715,9 @@ protected:
} }
#ifndef NDEBUG #ifndef NDEBUG
template<typename Iterator> template <typename Iterator>
static size_t _fastSetChecksum(Iterator begin, Iterator end) { static size_t _fastSetChecksum(Iterator begin, Iterator end)
{
std::hash<typename Iterator::value_type> hasher; std::hash<typename Iterator::value_type> hasher;
size_t checksum = 0; size_t checksum = 0;
for (Iterator it = begin; it != end; ++it) { for (Iterator it = begin; it != end; ++it) {
@ -808,13 +730,12 @@ protected:
// Reorder children [from, to) to the order given by `neworder` // Reorder children [from, to) to the order given by `neworder`
void reorderChildren( void reorderChildren(
std::list<IGUIElement*>::iterator from, std::list<IGUIElement *>::iterator from,
std::list<IGUIElement*>::iterator to, std::list<IGUIElement *>::iterator to,
const std::vector<IGUIElement*> &neworder) const std::vector<IGUIElement *> &neworder)
{ {
assert(_fastSetChecksum(from, to) == _fastSetChecksum(neworder.begin(), neworder.end())); assert(_fastSetChecksum(from, to) == _fastSetChecksum(neworder.begin(), neworder.end()));
for (auto e : neworder) for (auto e : neworder) {
{
*from = e; *from = e;
e->ParentPos = from; e->ParentPos = from;
++from; ++from;
@ -822,26 +743,22 @@ protected:
assert(from == to); assert(from == to);
} }
// not virtual because needed in constructor // not virtual because needed in constructor
void recalculateAbsolutePosition(bool recursive) void recalculateAbsolutePosition(bool recursive)
{ {
core::rect<s32> parentAbsolute(0,0,0,0); core::rect<s32> parentAbsolute(0, 0, 0, 0);
core::rect<s32> parentAbsoluteClip; core::rect<s32> parentAbsoluteClip;
f32 fw=0.f, fh=0.f; f32 fw = 0.f, fh = 0.f;
if (Parent) if (Parent) {
{
parentAbsolute = Parent->AbsoluteRect; parentAbsolute = Parent->AbsoluteRect;
if (NoClip) if (NoClip) {
{ IGUIElement *p = this;
IGUIElement* p=this;
while (p->Parent) while (p->Parent)
p = p->Parent; p = p->Parent;
parentAbsoluteClip = p->AbsoluteClippingRect; parentAbsoluteClip = p->AbsoluteClippingRect;
} } else
else
parentAbsoluteClip = Parent->AbsoluteClippingRect; parentAbsoluteClip = Parent->AbsoluteClippingRect;
} }
@ -854,64 +771,60 @@ protected:
if (AlignTop == EGUIA_SCALE || AlignBottom == EGUIA_SCALE) if (AlignTop == EGUIA_SCALE || AlignBottom == EGUIA_SCALE)
fh = (f32)parentAbsolute.getHeight(); fh = (f32)parentAbsolute.getHeight();
switch (AlignLeft) switch (AlignLeft) {
{ case EGUIA_UPPERLEFT:
case EGUIA_UPPERLEFT: break;
break; case EGUIA_LOWERRIGHT:
case EGUIA_LOWERRIGHT: DesiredRect.UpperLeftCorner.X += diffx;
DesiredRect.UpperLeftCorner.X += diffx; break;
break; case EGUIA_CENTER:
case EGUIA_CENTER: DesiredRect.UpperLeftCorner.X += diffx / 2;
DesiredRect.UpperLeftCorner.X += diffx/2; break;
break; case EGUIA_SCALE:
case EGUIA_SCALE: DesiredRect.UpperLeftCorner.X = core::round32(ScaleRect.UpperLeftCorner.X * fw);
DesiredRect.UpperLeftCorner.X = core::round32(ScaleRect.UpperLeftCorner.X * fw); break;
break;
} }
switch (AlignRight) switch (AlignRight) {
{ case EGUIA_UPPERLEFT:
case EGUIA_UPPERLEFT: break;
break; case EGUIA_LOWERRIGHT:
case EGUIA_LOWERRIGHT: DesiredRect.LowerRightCorner.X += diffx;
DesiredRect.LowerRightCorner.X += diffx; break;
break; case EGUIA_CENTER:
case EGUIA_CENTER: DesiredRect.LowerRightCorner.X += diffx / 2;
DesiredRect.LowerRightCorner.X += diffx/2; break;
break; case EGUIA_SCALE:
case EGUIA_SCALE: DesiredRect.LowerRightCorner.X = core::round32(ScaleRect.LowerRightCorner.X * fw);
DesiredRect.LowerRightCorner.X = core::round32(ScaleRect.LowerRightCorner.X * fw); break;
break;
} }
switch (AlignTop) switch (AlignTop) {
{ case EGUIA_UPPERLEFT:
case EGUIA_UPPERLEFT: break;
break; case EGUIA_LOWERRIGHT:
case EGUIA_LOWERRIGHT: DesiredRect.UpperLeftCorner.Y += diffy;
DesiredRect.UpperLeftCorner.Y += diffy; break;
break; case EGUIA_CENTER:
case EGUIA_CENTER: DesiredRect.UpperLeftCorner.Y += diffy / 2;
DesiredRect.UpperLeftCorner.Y += diffy/2; break;
break; case EGUIA_SCALE:
case EGUIA_SCALE: DesiredRect.UpperLeftCorner.Y = core::round32(ScaleRect.UpperLeftCorner.Y * fh);
DesiredRect.UpperLeftCorner.Y = core::round32(ScaleRect.UpperLeftCorner.Y * fh); break;
break;
} }
switch (AlignBottom) switch (AlignBottom) {
{ case EGUIA_UPPERLEFT:
case EGUIA_UPPERLEFT: break;
break; case EGUIA_LOWERRIGHT:
case EGUIA_LOWERRIGHT: DesiredRect.LowerRightCorner.Y += diffy;
DesiredRect.LowerRightCorner.Y += diffy; break;
break; case EGUIA_CENTER:
case EGUIA_CENTER: DesiredRect.LowerRightCorner.Y += diffy / 2;
DesiredRect.LowerRightCorner.Y += diffy/2; break;
break; case EGUIA_SCALE:
case EGUIA_SCALE: DesiredRect.LowerRightCorner.Y = core::round32(ScaleRect.LowerRightCorner.Y * fh);
DesiredRect.LowerRightCorner.Y = core::round32(ScaleRect.LowerRightCorner.Y * fh); break;
break;
} }
RelativeRect = DesiredRect; RelativeRect = DesiredRect;
@ -941,26 +854,23 @@ protected:
LastParentRect = parentAbsolute; LastParentRect = parentAbsolute;
if ( recursive ) if (recursive) {
{
// update all children // update all children
for (auto child : Children) for (auto child : Children) {
{
child->recalculateAbsolutePosition(recursive); child->recalculateAbsolutePosition(recursive);
} }
} }
} }
protected: protected:
//! List of all children of this element //! List of all children of this element
std::list<IGUIElement*> Children; std::list<IGUIElement *> Children;
//! Pointer to the parent //! Pointer to the parent
IGUIElement* Parent; IGUIElement *Parent;
//! Our position in the parent list. Only valid when Parent != nullptr //! Our position in the parent list. Only valid when Parent != nullptr
std::list<IGUIElement*>::iterator ParentPos; std::list<IGUIElement *>::iterator ParentPos;
//! relative rect of element //! relative rect of element
core::rect<s32> RelativeRect; core::rect<s32> RelativeRect;
@ -1021,12 +931,11 @@ protected:
EGUI_ALIGNMENT AlignLeft, AlignRight, AlignTop, AlignBottom; EGUI_ALIGNMENT AlignLeft, AlignRight, AlignTop, AlignBottom;
//! GUI Environment //! GUI Environment
IGUIEnvironment* Environment; IGUIEnvironment *Environment;
//! type of element //! type of element
EGUI_ELEMENT_TYPE Type; EGUI_ELEMENT_TYPE Type;
}; };
} // end namespace gui } // end namespace gui
} // end namespace irr } // end namespace irr

137
include/IGUIEnvironment.h
View File

@ -13,20 +13,20 @@
namespace irr namespace irr
{ {
class IOSOperator; class IOSOperator;
class IEventReceiver; class IEventReceiver;
namespace io namespace io
{ {
class IReadFile; class IReadFile;
class IWriteFile; class IWriteFile;
class IFileSystem; class IFileSystem;
} // end namespace io } // end namespace io
namespace video namespace video
{ {
class IVideoDriver; class IVideoDriver;
class ITexture; class ITexture;
} // end namespace video } // end namespace video
namespace gui namespace gui
{ {
@ -58,11 +58,10 @@ class IGUIWindow;
class IGUIEnvironment : public virtual IReferenceCounted class IGUIEnvironment : public virtual IReferenceCounted
{ {
public: public:
//! Draws all gui elements by traversing the GUI environment starting at the root node. //! Draws all gui elements by traversing the GUI environment starting at the root node.
/** \param When true ensure the GuiEnvironment (aka the RootGUIElement) has the same size as the current driver screensize. /** \param When true ensure the GuiEnvironment (aka the RootGUIElement) has the same size as the current driver screensize.
Can be set to false to control that size yourself, p.E when not the full size should be used for UI. */ Can be set to false to control that size yourself, p.E when not the full size should be used for UI. */
virtual void drawAll(bool useScreenSize=true) = 0; virtual void drawAll(bool useScreenSize = true) = 0;
//! Sets the focus to an element. //! Sets the focus to an element.
/** Causes a EGET_ELEMENT_FOCUS_LOST event followed by a /** Causes a EGET_ELEMENT_FOCUS_LOST event followed by a
@ -70,11 +69,11 @@ public:
then the focus will not be changed. then the focus will not be changed.
\param element Pointer to the element which shall get the focus. \param element Pointer to the element which shall get the focus.
\return True on success, false on failure */ \return True on success, false on failure */
virtual bool setFocus(IGUIElement* element) = 0; virtual bool setFocus(IGUIElement *element) = 0;
//! Returns the element which holds the focus. //! Returns the element which holds the focus.
/** \return Pointer to the element with focus. */ /** \return Pointer to the element with focus. */
virtual IGUIElement* getFocus() const = 0; virtual IGUIElement *getFocus() const = 0;
//! Returns the element which was last under the mouse cursor //! Returns the element which was last under the mouse cursor
/** NOTE: This information is updated _after_ the user-eventreceiver /** NOTE: This information is updated _after_ the user-eventreceiver
@ -82,32 +81,32 @@ public:
mouse events you have to use instead: mouse events you have to use instead:
IGUIEnvironment::getRootGUIElement()->getElementFromPoint(mousePos); IGUIEnvironment::getRootGUIElement()->getElementFromPoint(mousePos);
\return Pointer to the element under the mouse. */ \return Pointer to the element under the mouse. */
virtual IGUIElement* getHovered() const = 0; virtual IGUIElement *getHovered() const = 0;
//! Removes the focus from an element. //! Removes the focus from an element.
/** Causes a EGET_ELEMENT_FOCUS_LOST event. If the event is absorbed /** Causes a EGET_ELEMENT_FOCUS_LOST event. If the event is absorbed
then the focus will not be changed. then the focus will not be changed.
\param element Pointer to the element which shall lose the focus. \param element Pointer to the element which shall lose the focus.
\return True on success, false on failure */ \return True on success, false on failure */
virtual bool removeFocus(IGUIElement* element) = 0; virtual bool removeFocus(IGUIElement *element) = 0;
//! Returns whether the element has focus //! Returns whether the element has focus
/** \param element Pointer to the element which is tested. /** \param element Pointer to the element which is tested.
\param checkSubElements When true and focus is on a sub-element of element then it will still count as focused and return true \param checkSubElements When true and focus is on a sub-element of element then it will still count as focused and return true
\return True if the element has focus, else false. */ \return True if the element has focus, else false. */
virtual bool hasFocus(const IGUIElement* element, bool checkSubElements=false) const = 0; virtual bool hasFocus(const IGUIElement *element, bool checkSubElements = false) const = 0;
//! Returns the current video driver. //! Returns the current video driver.
/** \return Pointer to the video driver. */ /** \return Pointer to the video driver. */
virtual video::IVideoDriver* getVideoDriver() const = 0; virtual video::IVideoDriver *getVideoDriver() const = 0;
//! Returns the file system. //! Returns the file system.
/** \return Pointer to the file system. */ /** \return Pointer to the file system. */
virtual io::IFileSystem* getFileSystem() const = 0; virtual io::IFileSystem *getFileSystem() const = 0;
//! returns a pointer to the OS operator //! returns a pointer to the OS operator
/** \return Pointer to the OS operator. */ /** \return Pointer to the OS operator. */
virtual IOSOperator* getOSOperator() const = 0; virtual IOSOperator *getOSOperator() const = 0;
//! Removes all elements from the environment. //! Removes all elements from the environment.
virtual void clear() = 0; virtual void clear() = 0;
@ -117,17 +116,17 @@ public:
use this method, it is used by the engine internally. use this method, it is used by the engine internally.
\param event The event to post. \param event The event to post.
\return True if succeeded, else false. */ \return True if succeeded, else false. */
virtual bool postEventFromUser(const SEvent& event) = 0; virtual bool postEventFromUser(const SEvent &event) = 0;
//! This sets a new event receiver for gui events. //! This sets a new event receiver for gui events.
/** Usually you do not have to /** Usually you do not have to
use this method, it is used by the engine internally. use this method, it is used by the engine internally.
\param evr Pointer to the new receiver. */ \param evr Pointer to the new receiver. */
virtual void setUserEventReceiver(IEventReceiver* evr) = 0; virtual void setUserEventReceiver(IEventReceiver *evr) = 0;
//! Returns pointer to the current gui skin. //! Returns pointer to the current gui skin.
/** \return Pointer to the GUI skin. */ /** \return Pointer to the GUI skin. */
virtual IGUISkin* getSkin() const = 0; virtual IGUISkin *getSkin() const = 0;
//! Sets a new GUI Skin //! Sets a new GUI Skin
/** You can use this to change the appearance of the whole GUI /** You can use this to change the appearance of the whole GUI
@ -142,7 +141,7 @@ public:
\endcode \endcode
\param skin New skin to use. \param skin New skin to use.
*/ */
virtual void setSkin(IGUISkin* skin) = 0; virtual void setSkin(IGUISkin *skin) = 0;
//! Creates a new GUI Skin based on a template. //! Creates a new GUI Skin based on a template.
/** Use setSkin() to set the created skin. /** Use setSkin() to set the created skin.
@ -150,8 +149,7 @@ public:
\return Pointer to the created skin. \return Pointer to the created skin.
If you no longer need it, you should call IGUISkin::drop(). If you no longer need it, you should call IGUISkin::drop().
See IReferenceCounted::drop() for more information. */ See IReferenceCounted::drop() for more information. */
virtual IGUISkin* createSkin(EGUI_SKIN_TYPE type) = 0; virtual IGUISkin *createSkin(EGUI_SKIN_TYPE type) = 0;
//! Creates the image list from the given texture. //! Creates the image list from the given texture.
/** \param texture Texture to split into images /** \param texture Texture to split into images
@ -160,9 +158,9 @@ public:
\return Pointer to the font. Returns 0 if the font could not be loaded. \return Pointer to the font. Returns 0 if the font could not be loaded.
This pointer should not be dropped. See IReferenceCounted::drop() for This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */ more information. */
virtual IGUIImageList* createImageList( video::ITexture* texture, virtual IGUIImageList *createImageList(video::ITexture *texture,
core::dimension2d<s32> imageSize, core::dimension2d<s32> imageSize,
bool useAlphaChannel ) = 0; bool useAlphaChannel) = 0;
//! Returns pointer to the font with the specified filename. //! Returns pointer to the font with the specified filename.
/** Loads the font if it was not loaded before. /** Loads the font if it was not loaded before.
@ -170,7 +168,7 @@ public:
\return Pointer to the font. Returns 0 if the font could not be loaded. \return Pointer to the font. Returns 0 if the font could not be loaded.
This pointer should not be dropped. See IReferenceCounted::drop() for This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */ more information. */
virtual IGUIFont* getFont(const io::path& filename) = 0; virtual IGUIFont *getFont(const io::path &filename) = 0;
//! Adds an externally loaded font to the font list. //! Adds an externally loaded font to the font list.
/** This method allows to attach an already loaded font to the list of /** This method allows to attach an already loaded font to the list of
@ -178,29 +176,29 @@ public:
\param name Name the font should be stored as. \param name Name the font should be stored as.
\param font Pointer to font to add. \param font Pointer to font to add.
\return Pointer to the font stored. This can differ from given parameter if the name previously existed. */ \return Pointer to the font stored. This can differ from given parameter if the name previously existed. */
virtual IGUIFont* addFont(const io::path& name, IGUIFont* font) = 0; virtual IGUIFont *addFont(const io::path &name, IGUIFont *font) = 0;
//! remove loaded font //! remove loaded font
virtual void removeFont(IGUIFont* font) = 0; virtual void removeFont(IGUIFont *font) = 0;
//! Returns the default built-in font. //! Returns the default built-in font.
/** \return Pointer to the default built-in font. /** \return Pointer to the default built-in font.
This pointer should not be dropped. See IReferenceCounted::drop() for This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */ more information. */
virtual IGUIFont* getBuiltInFont() const = 0; virtual IGUIFont *getBuiltInFont() const = 0;
//! Returns pointer to the sprite bank which was added with addEmptySpriteBank //! Returns pointer to the sprite bank which was added with addEmptySpriteBank
/** TODO: This should load files in the future, but not implemented so far. /** TODO: This should load files in the future, but not implemented so far.
\param filename Name of a spritebank added with addEmptySpriteBank \param filename Name of a spritebank added with addEmptySpriteBank
\return Pointer to the sprite bank. Returns 0 if it could not be loaded. \return Pointer to the sprite bank. Returns 0 if it could not be loaded.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */ This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual IGUISpriteBank* getSpriteBank(const io::path& filename) = 0; virtual IGUISpriteBank *getSpriteBank(const io::path &filename) = 0;
//! Adds an empty sprite bank to the manager //! Adds an empty sprite bank to the manager
/** \param name Name of the new sprite bank. /** \param name Name of the new sprite bank.
\return Pointer to the sprite bank. \return Pointer to the sprite bank.
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */ This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
virtual IGUISpriteBank* addEmptySpriteBank(const io::path& name) = 0; virtual IGUISpriteBank *addEmptySpriteBank(const io::path &name) = 0;
//! Returns the root gui element. //! Returns the root gui element.
/** This is the first gui element, the (direct or indirect) parent of all /** This is the first gui element, the (direct or indirect) parent of all
@ -209,7 +207,7 @@ public:
\return Pointer to the root element of the GUI. The returned pointer \return Pointer to the root element of the GUI. The returned pointer
should not be dropped. See IReferenceCounted::drop() for more should not be dropped. See IReferenceCounted::drop() for more
information. */ information. */
virtual IGUIElement* getRootGUIElement() = 0; virtual IGUIElement *getRootGUIElement() = 0;
//! Adds a button element. //! Adds a button element.
/** \param rectangle Rectangle specifying the borders of the button. /** \param rectangle Rectangle specifying the borders of the button.
@ -220,8 +218,8 @@ public:
\return Pointer to the created button. Returns 0 if an error occurred. \return Pointer to the created button. Returns 0 if an error occurred.
This pointer should not be dropped. See IReferenceCounted::drop() for This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */ more information. */
virtual IGUIButton* addButton(const core::rect<s32>& rectangle, virtual IGUIButton *addButton(const core::rect<s32> &rectangle,
IGUIElement* parent=0, s32 id=-1, const wchar_t* text=0, const wchar_t* tooltiptext = 0) = 0; IGUIElement *parent = 0, s32 id = -1, const wchar_t *text = 0, const wchar_t *tooltiptext = 0) = 0;
//! Adds a scrollbar. //! Adds a scrollbar.
/** \param horizontal Specifies if the scroll bar is drawn horizontal /** \param horizontal Specifies if the scroll bar is drawn horizontal
@ -232,8 +230,8 @@ public:
\return Pointer to the created scrollbar. Returns 0 if an error \return Pointer to the created scrollbar. Returns 0 if an error
occurred. This pointer should not be dropped. See occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */ IReferenceCounted::drop() for more information. */
virtual IGUIScrollBar* addScrollBar(bool horizontal, const core::rect<s32>& rectangle, virtual IGUIScrollBar *addScrollBar(bool horizontal, const core::rect<s32> &rectangle,
IGUIElement* parent=0, s32 id=-1) = 0; IGUIElement *parent = 0, s32 id = -1) = 0;
//! Adds an image element. //! Adds an image element.
/** \param image Image to be displayed. /** \param image Image to be displayed.
@ -247,8 +245,8 @@ public:
\return Pointer to the created image element. Returns 0 if an error \return Pointer to the created image element. Returns 0 if an error
occurred. This pointer should not be dropped. See occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */ IReferenceCounted::drop() for more information. */
virtual IGUIImage* addImage(video::ITexture* image, core::position2d<s32> pos, virtual IGUIImage *addImage(video::ITexture *image, core::position2d<s32> pos,
bool useAlphaChannel=true, IGUIElement* parent=0, s32 id=-1, const wchar_t* text=0) = 0; bool useAlphaChannel = true, IGUIElement *parent = 0, s32 id = -1, const wchar_t *text = 0) = 0;
//! Adds an image element. //! Adds an image element.
/** Use IGUIImage::setImage later to set the image to be displayed. /** Use IGUIImage::setImage later to set the image to be displayed.
@ -261,8 +259,8 @@ public:
\return Pointer to the created image element. Returns 0 if an error \return Pointer to the created image element. Returns 0 if an error
occurred. This pointer should not be dropped. See occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */ IReferenceCounted::drop() for more information. */
virtual IGUIImage* addImage(const core::rect<s32>& rectangle, virtual IGUIImage *addImage(const core::rect<s32> &rectangle,
IGUIElement* parent=0, s32 id=-1, const wchar_t* text=0, bool useAlphaChannel=true) = 0; IGUIElement *parent = 0, s32 id = -1, const wchar_t *text = 0, bool useAlphaChannel = true) = 0;
//! Adds a checkbox element. //! Adds a checkbox element.
/** \param checked Define the initial state of the check box. /** \param checked Define the initial state of the check box.
@ -273,8 +271,8 @@ public:
\return Pointer to the created check box. Returns 0 if an error \return Pointer to the created check box. Returns 0 if an error
occurred. This pointer should not be dropped. See occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */ IReferenceCounted::drop() for more information. */
virtual IGUICheckBox* addCheckBox(bool checked, const core::rect<s32>& rectangle, virtual IGUICheckBox *addCheckBox(bool checked, const core::rect<s32> &rectangle,
IGUIElement* parent=0, s32 id=-1, const wchar_t* text=0) = 0; IGUIElement *parent = 0, s32 id = -1, const wchar_t *text = 0) = 0;
//! Adds a list box element. //! Adds a list box element.
/** \param rectangle Rectangle specifying the borders of the list box. /** \param rectangle Rectangle specifying the borders of the list box.
@ -284,8 +282,8 @@ public:
\return Pointer to the created list box. Returns 0 if an error occurred. \return Pointer to the created list box. Returns 0 if an error occurred.
This pointer should not be dropped. See IReferenceCounted::drop() for This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */ more information. */
virtual IGUIListBox* addListBox(const core::rect<s32>& rectangle, virtual IGUIListBox *addListBox(const core::rect<s32> &rectangle,
IGUIElement* parent=0, s32 id=-1, bool drawBackground=false) = 0; IGUIElement *parent = 0, s32 id = -1, bool drawBackground = false) = 0;
//! Adds a file open dialog. //! Adds a file open dialog.
/** \param title Text to be displayed as the title of the dialog. /** \param title Text to be displayed as the title of the dialog.
@ -301,9 +299,9 @@ public:
\return Pointer to the created file open dialog. Returns 0 if an error \return Pointer to the created file open dialog. Returns 0 if an error
occurred. This pointer should not be dropped. See occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */ IReferenceCounted::drop() for more information. */
virtual IGUIFileOpenDialog* addFileOpenDialog(const wchar_t* title=0, virtual IGUIFileOpenDialog *addFileOpenDialog(const wchar_t *title = 0,
bool modal=true, IGUIElement* parent=0, s32 id=-1, bool modal = true, IGUIElement *parent = 0, s32 id = -1,
bool restoreCWD=false, io::path::char_type* startDir=0) = 0; bool restoreCWD = false, io::path::char_type *startDir = 0) = 0;
//! Adds a static text. //! Adds a static text.
/** \param text Text to be displayed. Can be altered after creation by SetText(). /** \param text Text to be displayed. Can be altered after creation by SetText().
@ -317,9 +315,9 @@ public:
\return Pointer to the created static text. Returns 0 if an error \return Pointer to the created static text. Returns 0 if an error
occurred. This pointer should not be dropped. See occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */ IReferenceCounted::drop() for more information. */
virtual IGUIStaticText* addStaticText(const wchar_t* text, const core::rect<s32>& rectangle, virtual IGUIStaticText *addStaticText(const wchar_t *text, const core::rect<s32> &rectangle,
bool border=false, bool wordWrap=true, IGUIElement* parent=0, s32 id=-1, bool border = false, bool wordWrap = true, IGUIElement *parent = 0, s32 id = -1,
bool fillBackground = false) = 0; bool fillBackground = false) = 0;
//! Adds an edit box. //! Adds an edit box.
/** Supports Unicode input from every keyboard around the world, /** Supports Unicode input from every keyboard around the world,
@ -336,8 +334,8 @@ public:
\return Pointer to the created edit box. Returns 0 if an error occurred. \return Pointer to the created edit box. Returns 0 if an error occurred.
This pointer should not be dropped. See IReferenceCounted::drop() for This pointer should not be dropped. See IReferenceCounted::drop() for
more information. */ more information. */
virtual IGUIEditBox* addEditBox(const wchar_t* text, const core::rect<s32>& rectangle, virtual IGUIEditBox *addEditBox(const wchar_t *text, const core::rect<s32> &rectangle,
bool border=true, IGUIElement* parent=0, s32 id=-1) = 0; bool border = true, IGUIElement *parent = 0, s32 id = -1) = 0;
//! Adds a tab control to the environment. //! Adds a tab control to the environment.
/** \param rectangle Rectangle specifying the borders of the tab control. /** \param rectangle Rectangle specifying the borders of the tab control.
@ -352,9 +350,9 @@ public:
\return Pointer to the created tab control element. Returns 0 if an \return Pointer to the created tab control element. Returns 0 if an
error occurred. This pointer should not be dropped. See error occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */ IReferenceCounted::drop() for more information. */
virtual IGUITabControl* addTabControl(const core::rect<s32>& rectangle, virtual IGUITabControl *addTabControl(const core::rect<s32> &rectangle,
IGUIElement* parent=0, bool fillbackground=false, IGUIElement *parent = 0, bool fillbackground = false,
bool border=true, s32 id=-1) = 0; bool border = true, s32 id = -1) = 0;
//! Adds tab to the environment. //! Adds tab to the environment.
/** You can use this element to group other elements. This is not used /** You can use this element to group other elements. This is not used
@ -367,8 +365,8 @@ public:
\return Pointer to the created tab. Returns 0 if an \return Pointer to the created tab. Returns 0 if an
error occurred. This pointer should not be dropped. See error occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */ IReferenceCounted::drop() for more information. */
virtual IGUITab* addTab(const core::rect<s32>& rectangle, virtual IGUITab *addTab(const core::rect<s32> &rectangle,
IGUIElement* parent=0, s32 id=-1) = 0; IGUIElement *parent = 0, s32 id = -1) = 0;
//! Adds a combo box to the environment. //! Adds a combo box to the environment.
/** \param rectangle Rectangle specifying the borders of the combo box. /** \param rectangle Rectangle specifying the borders of the combo box.
@ -378,8 +376,8 @@ public:
\return Pointer to the created combo box. Returns 0 if an \return Pointer to the created combo box. Returns 0 if an
error occurred. This pointer should not be dropped. See error occurred. This pointer should not be dropped. See
IReferenceCounted::drop() for more information. */ IReferenceCounted::drop() for more information. */
virtual IGUIComboBox* addComboBox(const core::rect<s32>& rectangle, virtual IGUIComboBox *addComboBox(const core::rect<s32> &rectangle,
IGUIElement* parent=0, s32 id=-1) = 0; IGUIElement *parent = 0, s32 id = -1) = 0;
//! Find the next element which would be selected when pressing the tab-key //! Find the next element which would be selected when pressing the tab-key
/** If you set the focus for the result you can manually force focus-changes like they /** If you set the focus for the result you can manually force focus-changes like they
@ -387,7 +385,7 @@ public:
\param reverse When true it will search backward (toward lower TabOrder numbers, like shift+tab) \param reverse When true it will search backward (toward lower TabOrder numbers, like shift+tab)
\param group When true it will search for the next tab-group (like ctrl+tab) \param group When true it will search for the next tab-group (like ctrl+tab)
*/ */
virtual IGUIElement* getNextElement(bool reverse=false, bool group=false) = 0; virtual IGUIElement *getNextElement(bool reverse = false, bool group = false) = 0;
//! Set the way the gui will handle automatic focus changes //! Set the way the gui will handle automatic focus changes
/** The default is (EFF_SET_ON_LMOUSE_DOWN | EFF_SET_ON_TAB). /** The default is (EFF_SET_ON_LMOUSE_DOWN | EFF_SET_ON_TAB).
@ -409,9 +407,8 @@ public:
Note that in general just calling IGUIElement::remove() is enough. Note that in general just calling IGUIElement::remove() is enough.
Unless you create your own GUI elements removing themselves you won't need it. Unless you create your own GUI elements removing themselves you won't need it.
\param element: Element to remove */ \param element: Element to remove */
virtual void addToDeletionQueue(IGUIElement* element) = 0; virtual void addToDeletionQueue(IGUIElement *element) = 0;
}; };
} // end namespace gui } // end namespace gui
} // end namespace irr } // end namespace irr

46
include/IGUIFileOpenDialog.h
View File

@ -12,35 +12,33 @@ namespace irr
namespace gui namespace gui
{ {
//! Standard file chooser dialog. //! Standard file chooser dialog.
/** \warning When the user selects a folder this does change the current working directory /** \warning When the user selects a folder this does change the current working directory
\par This element can create the following events of type EGUI_EVENT_TYPE: \par This element can create the following events of type EGUI_EVENT_TYPE:
\li EGET_DIRECTORY_SELECTED \li EGET_DIRECTORY_SELECTED
\li EGET_FILE_SELECTED \li EGET_FILE_SELECTED
\li EGET_FILE_CHOOSE_DIALOG_CANCELLED \li EGET_FILE_CHOOSE_DIALOG_CANCELLED
*/ */
class IGUIFileOpenDialog : public IGUIElement class IGUIFileOpenDialog : public IGUIElement
{ {
public: public:
//! constructor
IGUIFileOpenDialog(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_FILE_OPEN_DIALOG, environment, parent, id, rectangle) {}
//! constructor //! Returns the filename of the selected file converted to wide characters. Returns NULL if no file was selected.
IGUIFileOpenDialog(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle) virtual const wchar_t *getFileName() const = 0;
: IGUIElement(EGUIET_FILE_OPEN_DIALOG, environment, parent, id, rectangle) {}
//! Returns the filename of the selected file converted to wide characters. Returns NULL if no file was selected. //! Returns the filename of the selected file. Is empty if no file was selected.
virtual const wchar_t* getFileName() const = 0; virtual const io::path &getFileNameP() const = 0;
//! Returns the filename of the selected file. Is empty if no file was selected. //! Returns the directory of the selected file. Empty if no directory was selected.
virtual const io::path& getFileNameP() const = 0; virtual const io::path &getDirectoryName() const = 0;
//! Returns the directory of the selected file. Empty if no directory was selected.
virtual const io::path& getDirectoryName() const = 0;
//! Returns the directory of the selected file converted to wide characters. Returns NULL if no directory was selected.
virtual const wchar_t* getDirectoryNameW() const = 0;
};
//! Returns the directory of the selected file converted to wide characters. Returns NULL if no directory was selected.
virtual const wchar_t *getDirectoryNameW() const = 0;
};
} // end namespace gui } // end namespace gui
} // end namespace irr } // end namespace irr

19
include/IGUIFont.h
View File

@ -38,7 +38,6 @@ enum EGUI_FONT_TYPE
class IGUIFont : public virtual IReferenceCounted class IGUIFont : public virtual IReferenceCounted
{ {
public: public:
//! Draws some text and clips it to the specified rectangle if wanted. //! Draws some text and clips it to the specified rectangle if wanted.
/** \param text: Text to draw /** \param text: Text to draw
\param position: Rectangle specifying position where to draw the text. \param position: Rectangle specifying position where to draw the text.
@ -47,30 +46,30 @@ public:
\param vcenter: Specifies if the text should be centered vertically into the rectangle. \param vcenter: Specifies if the text should be centered vertically into the rectangle.
\param clip: Optional pointer to a rectangle against which the text will be clipped. \param clip: Optional pointer to a rectangle against which the text will be clipped.
If the pointer is null, no clipping will be done. */ If the pointer is null, no clipping will be done. */
virtual void draw(const core::stringw& text, const core::rect<s32>& position, virtual void draw(const core::stringw &text, const core::rect<s32> &position,
video::SColor color, bool hcenter=false, bool vcenter=false, video::SColor color, bool hcenter = false, bool vcenter = false,
const core::rect<s32>* clip=0) = 0; const core::rect<s32> *clip = 0) = 0;
//! Calculates the width and height of a given string of text. //! Calculates the width and height of a given string of text.
/** \return Returns width and height of the area covered by the text if /** \return Returns width and height of the area covered by the text if
it would be drawn. */ it would be drawn. */
virtual core::dimension2d<u32> getDimension(const wchar_t* text) const = 0; virtual core::dimension2d<u32> getDimension(const wchar_t *text) const = 0;
//! Calculates the index of the character in the text which is on a specific position. //! Calculates the index of the character in the text which is on a specific position.
/** \param text: Text string. /** \param text: Text string.
\param pixel_x: X pixel position of which the index of the character will be returned. \param pixel_x: X pixel position of which the index of the character will be returned.
\return Returns zero based index of the character in the text, and -1 if no no character \return Returns zero based index of the character in the text, and -1 if no no character
is on this position. (=the text is too short). */ is on this position. (=the text is too short). */
virtual s32 getCharacterFromPos(const wchar_t* text, s32 pixel_x) const = 0; virtual s32 getCharacterFromPos(const wchar_t *text, s32 pixel_x) const = 0;
//! Returns the type of this font //! Returns the type of this font
virtual EGUI_FONT_TYPE getType() const { return EGFT_CUSTOM; } virtual EGUI_FONT_TYPE getType() const { return EGFT_CUSTOM; }
//! Sets global kerning width for the font. //! Sets global kerning width for the font.
virtual void setKerningWidth (s32 kerning) = 0; virtual void setKerningWidth(s32 kerning) = 0;
//! Sets global kerning height for the font. //! Sets global kerning height for the font.
virtual void setKerningHeight (s32 kerning) = 0; virtual void setKerningHeight(s32 kerning) = 0;
//! Gets kerning values (distance between letters) for the font. If no parameters are provided, //! Gets kerning values (distance between letters) for the font. If no parameters are provided,
/** the global kerning distance is returned. /** the global kerning distance is returned.
@ -83,7 +82,7 @@ public:
which supports kerning pairs a string such as 'Wo' may have the 'o' which supports kerning pairs a string such as 'Wo' may have the 'o'
tucked neatly under the 'W'. tucked neatly under the 'W'.
*/ */
virtual s32 getKerningWidth(const wchar_t* thisLetter=0, const wchar_t* previousLetter=0) const = 0; virtual s32 getKerningWidth(const wchar_t *thisLetter = 0, const wchar_t *previousLetter = 0) const = 0;
//! Returns the distance between letters //! Returns the distance between letters
virtual s32 getKerningHeight() const = 0; virtual s32 getKerningHeight() const = 0;
@ -93,7 +92,7 @@ public:
most fonts. most fonts.
\param s String of symbols which are not send down to the videodriver \param s String of symbols which are not send down to the videodriver
*/ */
virtual void setInvisibleCharacters( const wchar_t *s ) = 0; virtual void setInvisibleCharacters(const wchar_t *s) = 0;
}; };
} // end namespace gui } // end namespace gui

7
include/IGUIFontBitmap.h
View File

@ -10,18 +10,17 @@ namespace irr
{ {
namespace gui namespace gui
{ {
class IGUISpriteBank; class IGUISpriteBank;
//! Font interface. //! Font interface.
class IGUIFontBitmap : public IGUIFont class IGUIFontBitmap : public IGUIFont
{ {
public: public:
//! Returns the type of this font //! Returns the type of this font
EGUI_FONT_TYPE getType() const override { return EGFT_BITMAP; } EGUI_FONT_TYPE getType() const override { return EGFT_BITMAP; }
//! returns the parsed Symbol Information //! returns the parsed Symbol Information
virtual IGUISpriteBank* getSpriteBank() const = 0; virtual IGUISpriteBank *getSpriteBank() const = 0;
//! returns the sprite number from a given character //! returns the sprite number from a given character
virtual u32 getSpriteNoFromChar(const wchar_t *c) const = 0; virtual u32 getSpriteNoFromChar(const wchar_t *c) const = 0;
@ -35,7 +34,7 @@ public:
kerning value. For example, EGFT_BITMAP will add the right kerning value of previousLetter to the kerning value. For example, EGFT_BITMAP will add the right kerning value of previousLetter to the
left side kerning value of thisLetter, then add the global value. left side kerning value of thisLetter, then add the global value.
*/ */
s32 getKerningWidth(const wchar_t* thisLetter=0, const wchar_t* previousLetter=0) const override = 0; s32 getKerningWidth(const wchar_t *thisLetter = 0, const wchar_t *previousLetter = 0) const override = 0;
}; };
} // end namespace gui } // end namespace gui

102
include/IGUIImage.h
View File

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

7
include/IGUIImageList.h
View File

@ -16,17 +16,16 @@ namespace gui
class IGUIImageList : public virtual IReferenceCounted class IGUIImageList : public virtual IReferenceCounted
{ {
public: public:
//! Destructor //! Destructor
virtual ~IGUIImageList() {}; virtual ~IGUIImageList(){};
//! Draws an image and clips it to the specified rectangle if wanted //! Draws an image and clips it to the specified rectangle if wanted
//! \param index: Index of the image //! \param index: Index of the image
//! \param destPos: Position of the image to draw //! \param destPos: Position of the image to draw
//! \param clip: Optional pointer to a rectangle against which the text will be clipped. //! \param clip: Optional pointer to a rectangle against which the text will be clipped.
//! If the pointer is null, no clipping will be done. //! If the pointer is null, no clipping will be done.
virtual void draw(s32 index, const core::position2d<s32>& destPos, virtual void draw(s32 index, const core::position2d<s32> &destPos,
const core::rect<s32>* clip = 0) = 0; const core::rect<s32> *clip = 0) = 0;
//! Returns the count of Images in the list. //! Returns the count of Images in the list.
//! \return Returns the count of Images in the list. //! \return Returns the count of Images in the list.

236
include/IGUIListBox.h
View File

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

72
include/IGUIScrollBar.h
View File

@ -11,51 +11,49 @@ namespace irr
namespace gui namespace gui
{ {
//! Default scroll bar GUI element. //! Default scroll bar GUI element.
/** \par This element can create the following events of type EGUI_EVENT_TYPE: /** \par This element can create the following events of type EGUI_EVENT_TYPE:
\li EGET_SCROLL_BAR_CHANGED \li EGET_SCROLL_BAR_CHANGED
*/ */
class IGUIScrollBar : public IGUIElement class IGUIScrollBar : public IGUIElement
{ {
public: public:
//! constructor
IGUIScrollBar(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIElement(EGUIET_SCROLL_BAR, environment, parent, id, rectangle) {}
//! constructor //! sets the maximum value of the scrollbar.
IGUIScrollBar(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle) virtual void setMax(s32 max) = 0;
: IGUIElement(EGUIET_SCROLL_BAR, environment, parent, id, rectangle) {} //! gets the maximum value of the scrollbar.
virtual s32 getMax() const = 0;
//! sets the maximum value of the scrollbar. //! sets the minimum value of the scrollbar.
virtual void setMax(s32 max) = 0; virtual void setMin(s32 min) = 0;
//! gets the maximum value of the scrollbar. //! gets the minimum value of the scrollbar.
virtual s32 getMax() const = 0; virtual s32 getMin() const = 0;
//! sets the minimum value of the scrollbar. //! gets the small step value
virtual void setMin(s32 min) = 0; virtual s32 getSmallStep() const = 0;
//! gets the minimum value of the scrollbar.
virtual s32 getMin() const = 0;
//! gets the small step value //! Sets the small step
virtual s32 getSmallStep() const = 0; /** That is the amount that the value changes by when clicking
on the buttons or using the cursor keys. */
virtual void setSmallStep(s32 step) = 0;
//! Sets the small step //! gets the large step value
/** That is the amount that the value changes by when clicking virtual s32 getLargeStep() const = 0;
on the buttons or using the cursor keys. */
virtual void setSmallStep(s32 step) = 0;
//! gets the large step value //! Sets the large step
virtual s32 getLargeStep() const = 0; /** That is the amount that the value changes by when clicking
in the tray, or using the page up and page down keys. */
virtual void setLargeStep(s32 step) = 0;
//! Sets the large step //! gets the current position of the scrollbar
/** That is the amount that the value changes by when clicking virtual s32 getPos() const = 0;
in the tray, or using the page up and page down keys. */
virtual void setLargeStep(s32 step) = 0;
//! gets the current position of the scrollbar
virtual s32 getPos() const = 0;
//! sets the current position of the scrollbar
virtual void setPos(s32 pos) = 0;
};
//! sets the current position of the scrollbar
virtual void setPos(s32 pos) = 0;
};
} // end namespace gui } // end namespace gui
} // end namespace irr } // end namespace irr

1015
include/IGUISkin.h
View File

File diff suppressed because it is too large Load Diff

62
include/IGUISpriteBank.h
View File

@ -14,7 +14,7 @@ namespace irr
namespace video namespace video
{ {
class ITexture; class ITexture;
} // end namespace video } // end namespace video
namespace gui namespace gui
@ -24,12 +24,13 @@ namespace gui
// Note for implementer: Can't fix variable names to uppercase as this is a public interface used since a while // Note for implementer: Can't fix variable names to uppercase as this is a public interface used since a while
struct SGUISpriteFrame struct SGUISpriteFrame
{ {
SGUISpriteFrame() : textureNumber(0), rectNumber(0) SGUISpriteFrame() :
textureNumber(0), rectNumber(0)
{ {
} }
SGUISpriteFrame(u32 textureIndex, u32 positionIndex) SGUISpriteFrame(u32 textureIndex, u32 positionIndex) :
: textureNumber(textureIndex), rectNumber(positionIndex) textureNumber(textureIndex), rectNumber(positionIndex)
{ {
} }
@ -44,8 +45,10 @@ struct SGUISpriteFrame
// Note for implementer: Can't fix variable names to uppercase as this is a public interface used since a while // Note for implementer: Can't fix variable names to uppercase as this is a public interface used since a while
struct SGUISprite struct SGUISprite
{ {
SGUISprite() : frameTime(0) {} SGUISprite() :
SGUISprite(const SGUISpriteFrame& firstFrame) : frameTime(0) frameTime(0) {}
SGUISprite(const SGUISpriteFrame &firstFrame) :
frameTime(0)
{ {
Frames.push_back(firstFrame); Frames.push_back(firstFrame);
} }
@ -54,37 +57,35 @@ struct SGUISprite
u32 frameTime; u32 frameTime;
}; };
//! Sprite bank interface. //! Sprite bank interface.
/** See http://http://irrlicht.sourceforge.net/forum//viewtopic.php?f=9&t=25742 /** See http://http://irrlicht.sourceforge.net/forum//viewtopic.php?f=9&t=25742
* for more information how to use the spritebank. * for more information how to use the spritebank.
*/ */
class IGUISpriteBank : public virtual IReferenceCounted class IGUISpriteBank : public virtual IReferenceCounted
{ {
public: public:
//! Returns the list of rectangles held by the sprite bank //! Returns the list of rectangles held by the sprite bank
virtual core::array< core::rect<s32> >& getPositions() = 0; virtual core::array<core::rect<s32>> &getPositions() = 0;
//! Returns the array of animated sprites within the sprite bank //! Returns the array of animated sprites within the sprite bank
virtual core::array< SGUISprite >& getSprites() = 0; virtual core::array<SGUISprite> &getSprites() = 0;
//! Returns the number of textures held by the sprite bank //! Returns the number of textures held by the sprite bank
virtual u32 getTextureCount() const = 0; virtual u32 getTextureCount() const = 0;
//! Gets the texture with the specified index //! Gets the texture with the specified index
virtual video::ITexture* getTexture(u32 index) const = 0; virtual video::ITexture *getTexture(u32 index) const = 0;
//! Adds a texture to the sprite bank //! Adds a texture to the sprite bank
virtual void addTexture(video::ITexture* texture) = 0; virtual void addTexture(video::ITexture *texture) = 0;
//! Changes one of the textures in the sprite bank //! Changes one of the textures in the sprite bank
virtual void setTexture(u32 index, video::ITexture* texture) = 0; virtual void setTexture(u32 index, video::ITexture *texture) = 0;
//! Add the texture and use it for a single non-animated sprite. //! Add the texture and use it for a single non-animated sprite.
/** The texture and the corresponding rectangle and sprite will all be added to the end of each array. /** The texture and the corresponding rectangle and sprite will all be added to the end of each array.
\returns The index of the sprite or -1 on failure */ \returns The index of the sprite or -1 on failure */
virtual s32 addTextureAsSprite(video::ITexture* texture) = 0; virtual s32 addTextureAsSprite(video::ITexture *texture) = 0;
//! Clears sprites, rectangles and textures //! Clears sprites, rectangles and textures
virtual void clear() = 0; virtual void clear() = 0;
@ -102,11 +103,11 @@ public:
\param loop When true animations are looped \param loop When true animations are looped
\param center When true pivot is set to the sprite-center. So it affects pos. \param center When true pivot is set to the sprite-center. So it affects pos.
*/ */
virtual void draw2DSprite(u32 index, const core::position2di& pos, virtual void draw2DSprite(u32 index, const core::position2di &pos,
const core::rect<s32>* clip=0, const core::rect<s32> *clip = 0,
const video::SColor& color= video::SColor(255,255,255,255), const video::SColor &color = video::SColor(255, 255, 255, 255),
u32 starttime=0, u32 currenttime=0, u32 starttime = 0, u32 currenttime = 0,
bool loop=true, bool center=false) = 0; bool loop = true, bool center = false) = 0;
//! Draws a sprite in 2d with destination rectangle and colors //! Draws a sprite in 2d with destination rectangle and colors
/** /**
@ -119,20 +120,19 @@ public:
(same as currenttime-starttime in other draw2DSprite function) (same as currenttime-starttime in other draw2DSprite function)
\param loop When true animations are looped \param loop When true animations are looped
*/ */
virtual void draw2DSprite(u32 index, const core::rect<s32>& destRect, virtual void draw2DSprite(u32 index, const core::rect<s32> &destRect,
const core::rect<s32>* clip=0, const core::rect<s32> *clip = 0,
const video::SColor * const colors=0, const video::SColor *const colors = 0,
u32 timeTicks = 0, u32 timeTicks = 0,
bool loop=true) = 0; bool loop = true) = 0;
//! Draws a sprite batch in 2d using an array of positions and a color //! Draws a sprite batch in 2d using an array of positions and a color
virtual void draw2DSpriteBatch(const core::array<u32>& indices, const core::array<core::position2di>& pos, virtual void draw2DSpriteBatch(const core::array<u32> &indices, const core::array<core::position2di> &pos,
const core::rect<s32>* clip=0, const core::rect<s32> *clip = 0,
const video::SColor& color= video::SColor(255,255,255,255), const video::SColor &color = video::SColor(255, 255, 255, 255),
u32 starttime=0, u32 currenttime=0, u32 starttime = 0, u32 currenttime = 0,
bool loop=true, bool center=false) = 0; bool loop = true, bool center = false) = 0;
}; };
} // end namespace gui } // end namespace gui
} // end namespace irr } // end namespace irr

188
include/IGUIStaticText.h
View File

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

208
include/IGUITabControl.h
View File

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

30
include/IGUIToolbar.h
View File

@ -10,27 +10,25 @@ namespace irr
{ {
namespace video namespace video
{ {
class ITexture; class ITexture;
} // end namespace video } // end namespace video
namespace gui namespace gui
{ {
class IGUIButton; class IGUIButton;
//! Stays at the top of its parent like the menu bar and contains tool buttons //! Stays at the top of its parent like the menu bar and contains tool buttons
class IGUIToolBar : public IGUIElement class IGUIToolBar : public IGUIElement
{ {
public: public:
//! constructor
//! constructor IGUIToolBar(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
IGUIToolBar(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle) IGUIElement(EGUIET_TOOL_BAR, environment, parent, id, rectangle) {}
: IGUIElement(EGUIET_TOOL_BAR, environment, parent, id, rectangle) {}
//! Adds a button to the tool bar
virtual IGUIButton* addButton(s32 id=-1, const wchar_t* text=0,const wchar_t* tooltiptext=0,
video::ITexture* img=0, video::ITexture* pressedimg=0,
bool isPushButton=false, bool useAlphaChannel=false) = 0;
};
//! Adds a button to the tool bar
virtual IGUIButton *addButton(s32 id = -1, const wchar_t *text = 0, const wchar_t *tooltiptext = 0,
video::ITexture *img = 0, video::ITexture *pressedimg = 0,
bool isPushButton = false, bool useAlphaChannel = false) = 0;
};
} // end namespace gui } // end namespace gui
} // end namespace irr } // end namespace irr

129
include/IImage.h
View File

@ -23,10 +23,9 @@ NOTE: Floating point formats are not well supported yet. Basically only getData(
class IImage : public virtual IReferenceCounted class IImage : public virtual IReferenceCounted
{ {
public: public:
//! constructor //! constructor
IImage(ECOLOR_FORMAT format, const core::dimension2d<u32>& size, bool deleteMemory) : IImage(ECOLOR_FORMAT format, const core::dimension2d<u32> &size, bool deleteMemory) :
Format(format), Size(size), Data(0), MipMapsData(0), BytesPerPixel(0), Pitch(0), DeleteMemory(deleteMemory), DeleteMipMapsMemory(false) Format(format), Size(size), Data(0), MipMapsData(0), BytesPerPixel(0), Pitch(0), DeleteMemory(deleteMemory), DeleteMipMapsMemory(false)
{ {
BytesPerPixel = getBitsPerPixelFromFormat(Format) / 8; BytesPerPixel = getBitsPerPixelFromFormat(Format) / 8;
Pitch = BytesPerPixel * Size.Width; Pitch = BytesPerPixel * Size.Width;
@ -49,7 +48,7 @@ public:
} }
//! Returns width and height of image data. //! Returns width and height of image data.
const core::dimension2d<u32>& getDimension() const const core::dimension2d<u32> &getDimension() const
{ {
return Size; return Size;
} }
@ -88,8 +87,7 @@ public:
//! Returns mask for red value of a pixel //! Returns mask for red value of a pixel
u32 getRedMask() const u32 getRedMask() const
{ {
switch (Format) switch (Format) {
{
case ECF_A1R5G5B5: case ECF_A1R5G5B5:
return 0x1F << 10; return 0x1F << 10;
case ECF_R5G6B5: case ECF_R5G6B5:
@ -106,8 +104,7 @@ public:
//! Returns mask for green value of a pixel //! Returns mask for green value of a pixel
u32 getGreenMask() const u32 getGreenMask() const
{ {
switch (Format) switch (Format) {
{
case ECF_A1R5G5B5: case ECF_A1R5G5B5:
return 0x1F << 5; return 0x1F << 5;
case ECF_R5G6B5: case ECF_R5G6B5:
@ -124,8 +121,7 @@ public:
//! Returns mask for blue value of a pixel //! Returns mask for blue value of a pixel
u32 getBlueMask() const u32 getBlueMask() const
{ {
switch (Format) switch (Format) {
{
case ECF_A1R5G5B5: case ECF_A1R5G5B5:
return 0x1F; return 0x1F;
case ECF_R5G6B5: case ECF_R5G6B5:
@ -142,8 +138,7 @@ public:
//! Returns mask for alpha value of a pixel //! Returns mask for alpha value of a pixel
u32 getAlphaMask() const u32 getAlphaMask() const
{ {
switch (Format) switch (Format) {
{
case ECF_A1R5G5B5: case ECF_A1R5G5B5:
return 0x1 << 15; return 0x1 << 15;
case ECF_R5G6B5: case ECF_R5G6B5:
@ -162,7 +157,7 @@ public:
\return Pointer to the image data. What type of data is pointed to \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 depends on the color format of the image. For example if the color
format is ECF_A8R8G8B8, it is of u32. */ format is ECF_A8R8G8B8, it is of u32. */
void* getData() const void *getData() const
{ {
return Data; return Data;
} }
@ -175,43 +170,38 @@ public:
return getMipMapsSize(Size, mipmapLevel); return getMipMapsSize(Size, mipmapLevel);
} }
//! Calculate mipmap size for a certain level //! Calculate mipmap size for a certain 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. */
static core::dimension2du getMipMapsSize(const core::dimension2du& sizeLevel0, u32 mipmapLevel) static core::dimension2du getMipMapsSize(const core::dimension2du &sizeLevel0, u32 mipmapLevel)
{ {
core::dimension2du result(sizeLevel0); core::dimension2du result(sizeLevel0);
u32 i=0; u32 i = 0;
while (i != mipmapLevel) while (i != mipmapLevel) {
{ if (result.Width > 1)
if (result.Width>1)
result.Width >>= 1; result.Width >>= 1;
if (result.Height>1) if (result.Height > 1)
result.Height>>=1; result.Height >>= 1;
++i; ++i;
if ( result.Width == 1 && result.Height == 1 && i < mipmapLevel ) if (result.Width == 1 && result.Height == 1 && i < mipmapLevel)
return core::dimension2du(0,0); return core::dimension2du(0, 0);
} }
return result; return result;
} }
//! Get mipmaps data. //! Get mipmaps data.
/** Note that different mip levels are just behind each other in memory block. /** Note that different mip levels are just behind each other in memory block.
So if you just get level 1 you also have the data for all other levels. So if you just get level 1 you also have the data for all other levels.
There is no level 0 - use getData to get the original image data. There is no level 0 - use getData to get the original image data.
*/ */
void* getMipMapsData(irr::u32 mipLevel=1) const void *getMipMapsData(irr::u32 mipLevel = 1) const
{ {
if ( MipMapsData && mipLevel > 0) if (MipMapsData && mipLevel > 0) {
{
size_t dataSize = 0; size_t dataSize = 0;
core::dimension2du mipSize(Size); core::dimension2du mipSize(Size);
u32 i = 1; // We want the start of data for this level, not end. u32 i = 1; // We want the start of data for this level, not end.
while (i != mipLevel) while (i != mipLevel) {
{
if (mipSize.Width > 1) if (mipSize.Width > 1)
mipSize.Width >>= 1; mipSize.Width >>= 1;
@ -221,7 +211,7 @@ public:
dataSize += getDataSizeFromFormat(Format, mipSize.Width, mipSize.Height); dataSize += getDataSizeFromFormat(Format, mipSize.Width, mipSize.Height);
++i; ++i;
if ( mipSize.Width == 1 && mipSize.Height == 1 && i < mipLevel) if (mipSize.Width == 1 && mipSize.Height == 1 && i < mipLevel)
return 0; return 0;
} }
@ -240,33 +230,26 @@ public:
will by copied internally. will by copied internally.
\param deleteMemory Whether the memory is deallocated upon \param deleteMemory Whether the memory is deallocated upon
destruction. */ destruction. */
void setMipMapsData(void* data, bool ownForeignMemory) void setMipMapsData(void *data, bool ownForeignMemory)
{ {
if (data != MipMapsData) if (data != MipMapsData) {
{ if (DeleteMipMapsMemory) {
if (DeleteMipMapsMemory)
{
delete[] MipMapsData; delete[] MipMapsData;
DeleteMipMapsMemory = false; DeleteMipMapsMemory = false;
} }
if (data) if (data) {
{ if (ownForeignMemory) {
if (ownForeignMemory) MipMapsData = static_cast<u8 *>(data);
{
MipMapsData = static_cast<u8*>(data);
DeleteMipMapsMemory = false; DeleteMipMapsMemory = false;
} } else {
else
{
u32 dataSize = 0; u32 dataSize = 0;
u32 width = Size.Width; u32 width = Size.Width;
u32 height = Size.Height; u32 height = Size.Height;
do do {
{
if (width > 1) if (width > 1)
width >>= 1; width >>= 1;
@ -281,9 +264,7 @@ public:
DeleteMipMapsMemory = true; DeleteMipMapsMemory = true;
} }
} } else {
else
{
MipMapsData = 0; MipMapsData = 0;
} }
} }
@ -293,51 +274,50 @@ public:
virtual SColor getPixel(u32 x, u32 y) const = 0; virtual SColor getPixel(u32 x, u32 y) const = 0;
//! Sets a pixel //! Sets a pixel
virtual void setPixel(u32 x, u32 y, const SColor &color, bool blend = false ) = 0; virtual void setPixel(u32 x, u32 y, const SColor &color, bool blend = false) = 0;
//! Copies this surface into another, if it has the exact same size and format. //! Copies this surface into another, if it has the exact same size and format.
/** NOTE: mipmaps are ignored /** NOTE: mipmaps are ignored
\return True if it was copied, false otherwise. \return True if it was copied, false otherwise.
*/ */
virtual bool copyToNoScaling(void *target, u32 width, u32 height, ECOLOR_FORMAT format=ECF_A8R8G8B8, u32 pitch=0) const = 0; virtual bool copyToNoScaling(void *target, u32 width, u32 height, ECOLOR_FORMAT format = ECF_A8R8G8B8, u32 pitch = 0) const = 0;
//! Copies the image into the target, scaling the image to fit //! Copies the image into the target, scaling the image to fit
/** NOTE: mipmaps are ignored */ /** NOTE: mipmaps are ignored */
virtual void copyToScaling(void* target, u32 width, u32 height, ECOLOR_FORMAT format=ECF_A8R8G8B8, u32 pitch=0) =0; virtual void copyToScaling(void *target, u32 width, u32 height, ECOLOR_FORMAT format = ECF_A8R8G8B8, u32 pitch = 0) = 0;
//! Copies the image into the target, scaling the image to fit //! Copies the image into the target, scaling the image to fit
/** NOTE: mipmaps are ignored */ /** NOTE: mipmaps are ignored */
virtual void copyToScaling(IImage* target) =0; virtual void copyToScaling(IImage *target) = 0;
//! copies this surface into another //! copies this surface into another
/** NOTE: mipmaps are ignored */ /** NOTE: mipmaps are ignored */
virtual void copyTo(IImage* target, const core::position2d<s32>& pos=core::position2d<s32>(0,0)) =0; virtual void copyTo(IImage *target, const core::position2d<s32> &pos = core::position2d<s32>(0, 0)) = 0;
//! copies this surface into another //! copies this surface into another
/** NOTE: mipmaps are ignored */ /** NOTE: mipmaps are ignored */
virtual void copyTo(IImage* target, const core::position2d<s32>& pos, const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect=0) =0; virtual void copyTo(IImage *target, const core::position2d<s32> &pos, const core::rect<s32> &sourceRect, const core::rect<s32> *clipRect = 0) = 0;
//! copies this surface into another, using the alpha mask and cliprect and a color to add with //! copies this surface into another, using the alpha mask and cliprect and a color to add with
/** NOTE: mipmaps are ignored /** NOTE: mipmaps are ignored
\param combineAlpha - When true then combine alpha channels. When false replace target image alpha with source image alpha. \param combineAlpha - When true then combine alpha channels. When false replace target image alpha with source image alpha.
*/ */
virtual void copyToWithAlpha(IImage* target, const core::position2d<s32>& pos, virtual void copyToWithAlpha(IImage *target, const core::position2d<s32> &pos,
const core::rect<s32>& sourceRect, const SColor &color, const core::rect<s32> &sourceRect, const SColor &color,
const core::rect<s32>* clipRect = 0, const core::rect<s32> *clipRect = 0,
bool combineAlpha=false) =0; bool combineAlpha = false) = 0;
//! copies this surface into another, scaling it to fit, applying a box filter //! copies this surface into another, scaling it to fit, applying a box filter
/** NOTE: mipmaps are ignored */ /** NOTE: mipmaps are ignored */
virtual void copyToScalingBoxFilter(IImage* target, s32 bias = 0, bool blend = false) = 0; virtual void copyToScalingBoxFilter(IImage *target, s32 bias = 0, bool blend = false) = 0;
//! 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;
//! 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)
{ {
switch(format) switch (format) {
{
case ECF_A1R5G5B5: case ECF_A1R5G5B5:
return 16; return 16;
case ECF_R5G6B5: case ECF_R5G6B5:
@ -396,14 +376,13 @@ public:
//! check if the color format is only viable for depth/stencil textures //! check if the color format is only viable for depth/stencil textures
static bool isDepthFormat(const ECOLOR_FORMAT format) static bool isDepthFormat(const ECOLOR_FORMAT format)
{ {
switch(format) switch (format) {
{ case ECF_D16:
case ECF_D16: case ECF_D32:
case ECF_D32: case ECF_D24S8:
case ECF_D24S8: return true;
return true; default:
default: return false;
return false;
} }
} }
@ -413,8 +392,7 @@ public:
if (isCompressedFormat(format)) if (isCompressedFormat(format))
return false; return false;
switch(format) switch (format) {
{
case ECF_R16F: case ECF_R16F:
case ECF_G16R16F: case ECF_G16R16F:
case ECF_A16B16G16R16F: case ECF_A16B16G16R16F:
@ -432,8 +410,8 @@ protected:
ECOLOR_FORMAT Format; ECOLOR_FORMAT Format;
core::dimension2d<u32> Size; core::dimension2d<u32> Size;
u8* Data; u8 *Data;
u8* MipMapsData; u8 *MipMapsData;
u32 BytesPerPixel; u32 BytesPerPixel;
u32 Pitch; u32 Pitch;
@ -442,6 +420,5 @@ protected:
bool DeleteMipMapsMemory; bool DeleteMipMapsMemory;
}; };
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

10
include/IImageLoader.h
View File

@ -14,7 +14,7 @@ namespace irr
{ {
namespace io namespace io
{ {
class IReadFile; class IReadFile;
} // end namespace io } // end namespace io
namespace video namespace video
{ {
@ -27,25 +27,23 @@ IVideoDriver::addExternalImageLoader() to the engine. */
class IImageLoader : public virtual IReferenceCounted class IImageLoader : public virtual IReferenceCounted
{ {
public: public:
//! Check if the file might be loaded by this class //! Check if the file might be loaded by this class
/** Check is based on the file extension (e.g. ".tga") /** Check is based on the file extension (e.g. ".tga")
\param filename Name of file to check. \param filename Name of file to check.
\return True if file seems to be loadable. */ \return True if file seems to be loadable. */
virtual bool isALoadableFileExtension(const io::path& filename) const = 0; virtual bool isALoadableFileExtension(const io::path &filename) const = 0;
//! Check if the file might be loaded by this class //! Check if the file might be loaded by this class
/** Check might look into the file. /** Check might look into the file.
\param file File handle to check. \param file File handle to check.
\return True if file seems to be loadable. */ \return True if file seems to be loadable. */
virtual bool isALoadableFileFormat(io::IReadFile* file) const = 0; virtual bool isALoadableFileFormat(io::IReadFile *file) const = 0;
//! Creates a surface from the file //! Creates a surface from the file
/** \param file File handle to check. /** \param file File handle to check.
\return Pointer to newly created image, or 0 upon error. */ \return Pointer to newly created image, or 0 upon error. */
virtual IImage* loadImage(io::IReadFile* file) const = 0; virtual IImage *loadImage(io::IReadFile *file) const = 0;
}; };
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

7
include/IImageWriter.h
View File

@ -12,13 +12,12 @@ namespace irr
{ {
namespace io namespace io
{ {
class IWriteFile; class IWriteFile;
} // end namespace io } // end namespace io
namespace video namespace video
{ {
class IImage; class IImage;
//! Interface for writing software image data. //! Interface for writing software image data.
class IImageWriter : public IReferenceCounted class IImageWriter : public IReferenceCounted
@ -27,7 +26,7 @@ public:
//! Check if this writer can write a file with the given extension //! Check if this writer can write a file with the given extension
/** \param filename Name of the file to check. /** \param filename Name of the file to check.
\return True if file extension specifies a writable type. */ \return True if file extension specifies a writable type. */
virtual bool isAWriteableFileExtension(const io::path& filename) const = 0; virtual bool isAWriteableFileExtension(const io::path &filename) const = 0;
//! Write image to file //! Write image to file
/** \param file File handle to write to. /** \param file File handle to write to.

54
include/IIndexBuffer.h
View File

@ -20,42 +20,40 @@ namespace video
namespace scene namespace scene
{ {
class IIndexBuffer : public virtual IReferenceCounted class IIndexBuffer : public virtual IReferenceCounted
{ {
public: public:
virtual void *getData() = 0;
virtual void* getData() =0; virtual video::E_INDEX_TYPE getType() const = 0;
virtual void setType(video::E_INDEX_TYPE IndexType) = 0;
virtual video::E_INDEX_TYPE getType() const =0; virtual u32 stride() const = 0;
virtual void setType(video::E_INDEX_TYPE IndexType) =0;
virtual u32 stride() const =0; virtual u32 size() const = 0;
virtual void push_back(const u32 &element) = 0;
virtual u32 operator[](u32 index) const = 0;
virtual u32 getLast() = 0;
virtual void setValue(u32 index, u32 value) = 0;
virtual void set_used(u32 usedNow) = 0;
virtual void reallocate(u32 new_size) = 0;
virtual u32 allocated_size() const = 0;
virtual u32 size() const =0; virtual void *pointer() = 0;
virtual void push_back (const u32 &element) =0;
virtual u32 operator [](u32 index) const =0;
virtual u32 getLast() =0;
virtual void setValue(u32 index, u32 value) =0;
virtual void set_used(u32 usedNow) =0;
virtual void reallocate(u32 new_size) =0;
virtual u32 allocated_size() const=0;
virtual void* pointer() =0; //! get the current hardware mapping hint
virtual E_HARDWARE_MAPPING getHardwareMappingHint() const = 0;
//! get the current hardware mapping hint //! set the hardware mapping hint, for driver
virtual E_HARDWARE_MAPPING getHardwareMappingHint() const =0; virtual void setHardwareMappingHint(E_HARDWARE_MAPPING NewMappingHint) = 0;
//! set the hardware mapping hint, for driver //! flags the meshbuffer as changed, reloads hardware buffers
virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) =0; virtual void setDirty() = 0;
//! flags the meshbuffer as changed, reloads hardware buffers
virtual void setDirty() = 0;
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
virtual u32 getChangedID() const = 0;
};
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
virtual u32 getChangedID() const = 0;
};
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

6
include/ILogger.h
View File

@ -32,12 +32,10 @@ enum ELOG_LEVEL
ELL_NONE ELL_NONE
}; };
//! Interface for logging messages, warnings and errors //! Interface for logging messages, warnings and errors
class ILogger : public virtual IReferenceCounted class ILogger : public virtual IReferenceCounted
{ {
public: public:
//! Destructor //! Destructor
virtual ~ILogger() {} virtual ~ILogger() {}
@ -60,7 +58,7 @@ public:
is just an informational text, set it to ELL_INFORMATION. Texts are is just an informational text, set it to ELL_INFORMATION. Texts are
filtered with these levels. If you want to be a text displayed, filtered with these levels. If you want to be a text displayed,
independent on what level filter is set, use ELL_NONE. */ independent on what level filter is set, use ELL_NONE. */
virtual void log(const c8* text, ELOG_LEVEL ll=ELL_INFORMATION) = 0; virtual void log(const c8 *text, ELOG_LEVEL ll = ELL_INFORMATION) = 0;
//! Prints out a text into the log //! Prints out a text into the log
/** \param text: Text to print out. /** \param text: Text to print out.
@ -71,7 +69,7 @@ public:
is just an informational text, set it to ELL_INFORMATION. Texts are is just an informational text, set it to ELL_INFORMATION. Texts are
filtered with these levels. If you want to be a text displayed, filtered with these levels. If you want to be a text displayed,
independent on what level filter is set, use ELL_NONE. */ independent on what level filter is set, use ELL_NONE. */
virtual void log(const c8* text, const c8* hint, ELOG_LEVEL ll=ELL_INFORMATION) = 0; virtual void log(const c8 *text, const c8 *hint, ELOG_LEVEL ll = ELL_INFORMATION) = 0;
}; };
} // end namespace } // end namespace

10
include/IMaterialRenderer.h
View File

@ -24,7 +24,6 @@ engine with new materials. */
class IMaterialRenderer : public virtual IReferenceCounted class IMaterialRenderer : public virtual IReferenceCounted
{ {
public: public:
//! Called by the IVideoDriver implementation the let the renderer set its needed render states. //! Called by the IVideoDriver implementation the let the renderer set its needed render states.
/** This is called during the IVideoDriver::setMaterial() call. /** This is called during the IVideoDriver::setMaterial() call.
When overriding this, you can set some renderstates or for example a When overriding this, you can set some renderstates or for example a
@ -47,8 +46,8 @@ public:
fogenable. fogenable.
\param services: Interface providing some methods for changing \param services: Interface providing some methods for changing
advanced, internal states of a IVideoDriver. */ advanced, internal states of a IVideoDriver. */
virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial, virtual void OnSetMaterial(const SMaterial &material, const SMaterial &lastMaterial,
bool resetAllRenderstates, IMaterialRendererServices* services) {} bool resetAllRenderstates, IMaterialRendererServices *services) {}
//! Called every time before a new bunch of geometry is being drawn using this material with for example drawIndexedTriangleList() call. //! Called every time before a new bunch of geometry is being drawn using this material with for example drawIndexedTriangleList() call.
/** OnSetMaterial should normally only be called if the renderer decides /** OnSetMaterial should normally only be called if the renderer decides
@ -68,7 +67,7 @@ public:
example if he doesn't support the specified vertex type. This is example if he doesn't support the specified vertex type. This is
actually done in D3D9 when using a normal mapped material with actually done in D3D9 when using a normal mapped material with
a vertex type other than EVT_TANGENTS. */ a vertex type other than EVT_TANGENTS. */
virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype) { return true; } virtual bool OnRender(IMaterialRendererServices *service, E_VERTEX_TYPE vtxtype) { return true; }
//! Called by the IVideoDriver to unset this material. //! Called by the IVideoDriver to unset this material.
/** Called during the IVideoDriver::setMaterial() call before the new /** Called during the IVideoDriver::setMaterial() call before the new
@ -95,9 +94,8 @@ public:
//! Access the callback provided by the users when creating shader materials //! Access the callback provided by the users when creating shader materials
/** \returns Returns either the users provided callback or 0 when no such /** \returns Returns either the users provided callback or 0 when no such
callback exists. Non-shader materials will always return 0. */ callback exists. Non-shader materials will always return 0. */
virtual IShaderConstantSetCallBack* getShaderConstantSetCallBack() const { return 0; } virtual IShaderConstantSetCallBack *getShaderConstantSetCallBack() const { return 0; }
}; };
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

26
include/IMaterialRendererServices.h
View File

@ -14,12 +14,10 @@ namespace video
class IVideoDriver; class IVideoDriver;
//! Interface providing some methods for changing advanced, internal states of a IVideoDriver. //! Interface providing some methods for changing advanced, internal states of a IVideoDriver.
class IMaterialRendererServices class IMaterialRendererServices
{ {
public: public:
//! Destructor //! Destructor
virtual ~IMaterialRendererServices() {} virtual ~IMaterialRendererServices() {}
@ -33,12 +31,12 @@ public:
\param lastMaterial The material used until now. \param lastMaterial The material used until now.
\param resetAllRenderstates Set to true if all renderstates should be \param resetAllRenderstates Set to true if all renderstates should be
set, regardless of their current state. */ set, regardless of their current state. */
virtual void setBasicRenderStates(const SMaterial& material, virtual void setBasicRenderStates(const SMaterial &material,
const SMaterial& lastMaterial, const SMaterial &lastMaterial,
bool resetAllRenderstates) = 0; bool resetAllRenderstates) = 0;
//! Return an index constant for the vertex shader based on a uniform variable name. //! Return an index constant for the vertex shader based on a uniform variable name.
virtual s32 getVertexShaderConstantID(const c8* name) = 0; virtual s32 getVertexShaderConstantID(const c8 *name) = 0;
//! Sets a value for a vertex shader uniform variable. //! Sets a value for a vertex shader uniform variable.
/** \param index Index of the variable (as received from getVertexShaderConstantID) /** \param index Index of the variable (as received from getVertexShaderConstantID)
@ -46,16 +44,16 @@ public:
\param count Amount of floats in array. \param count Amount of floats in array.
\return True if successful. \return True if successful.
*/ */
virtual bool setVertexShaderConstant(s32 index, const f32* floats, int count) = 0; virtual bool setVertexShaderConstant(s32 index, const f32 *floats, int count) = 0;
//! Int interface for the above. //! Int interface for the above.
virtual bool setVertexShaderConstant(s32 index, const s32* ints, int count) = 0; virtual bool setVertexShaderConstant(s32 index, const s32 *ints, int count) = 0;
//! Uint interface for the above. //! Uint interface for the above.
virtual bool setVertexShaderConstant(s32 index, const u32* ints, int count) = 0; virtual bool setVertexShaderConstant(s32 index, const u32 *ints, int count) = 0;
//! Return an index constant for the pixel shader for the given uniform variable name //! 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 value for the given pixel shader uniform variable //! 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
@ -65,17 +63,17 @@ public:
\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. */
virtual bool setPixelShaderConstant(s32 index, const f32* floats, int count) = 0; virtual bool setPixelShaderConstant(s32 index, const f32 *floats, int count) = 0;
//! Int interface for the above. //! Int interface for the above.
virtual bool setPixelShaderConstant(s32 index, const s32* ints, int count) = 0; virtual bool setPixelShaderConstant(s32 index, const s32 *ints, int count) = 0;
//! Uint interface for the above. //! Uint interface for the above.
virtual bool setPixelShaderConstant(s32 index, const u32* ints, int count) = 0; virtual bool setPixelShaderConstant(s32 index, const u32 *ints, int count) = 0;
//! 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;
}; };
} // end namespace video } // end namespace video

24
include/IMemoryReadFile.h
View File

@ -11,17 +11,17 @@ namespace irr
namespace io namespace io
{ {
//! Interface providing read access to a memory read file. //! Interface providing read access to a memory read file.
class IMemoryReadFile : public IReadFile class IMemoryReadFile : public IReadFile
{ {
public: public:
//! Get direct access to internal buffer of memory block used as file. //! Get direct access to internal buffer of memory block used as file.
/** It's usually better to use the IReadFile functions to access /** It's usually better to use the IReadFile functions to access
the file content. But as that buffer exist over the full life-time the file content. But as that buffer exist over the full life-time
of a CMemoryReadFile, it's sometimes nice to avoid the additional of a CMemoryReadFile, it's sometimes nice to avoid the additional
data-copy which read() needs. data-copy which read() needs.
*/ */
virtual const void *getBuffer() const = 0; virtual const void *getBuffer() const = 0;
}; };
} // end namespace io } // end namespace io
} // end namespace irr } // end namespace irr

212
include/IMesh.h
View File

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

311
include/IMeshBuffer.h
View File

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

202
include/IMeshCache.h
View File

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

10
include/IMeshLoader.h
View File

@ -11,11 +11,11 @@ namespace irr
{ {
namespace io namespace io
{ {
class IReadFile; class IReadFile;
} // end namespace io } // end namespace io
namespace scene namespace scene
{ {
class IAnimatedMesh; class IAnimatedMesh;
//! Class which is able to load an animated mesh from a file. //! Class which is able to load an animated mesh from a file.
/** If you want Irrlicht be able to load meshes of /** If you want Irrlicht be able to load meshes of
@ -25,7 +25,6 @@ ISceneManager::addExternalMeshLoader() to the engine. */
class IMeshLoader : public virtual IReferenceCounted class IMeshLoader : public virtual IReferenceCounted
{ {
public: public:
//! Constructor //! Constructor
IMeshLoader() {} IMeshLoader() {}
@ -37,16 +36,15 @@ public:
only. only.
\param filename Name of the file to test. \param filename Name of the file to test.
\return True if the file might be loaded by this class. */ \return True if the file might be loaded by this class. */
virtual bool isALoadableFileExtension(const io::path& filename) const = 0; virtual bool isALoadableFileExtension(const io::path &filename) const = 0;
//! Creates/loads an animated mesh from the file. //! Creates/loads an animated mesh from the file.
/** \param file File handler to load the file from. /** \param file File handler to load the file from.
\return Pointer to the created mesh. Returns 0 if loading failed. \return Pointer to the created mesh. Returns 0 if loading failed.
If you no longer need the mesh, you should call IAnimatedMesh::drop(). If you no longer need the mesh, you should call IAnimatedMesh::drop().
See IReferenceCounted::drop() for more information. */ See IReferenceCounted::drop() for more information. */
virtual IAnimatedMesh* createMesh(io::IReadFile* file) = 0; virtual IAnimatedMesh *createMesh(io::IReadFile *file) = 0;
}; };
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

275
include/IMeshManipulator.h
View File

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

18
include/IMeshSceneNode.h
View File

@ -13,28 +13,26 @@ namespace scene
class IMesh; class IMesh;
//! A scene node displaying a static mesh //! A scene node displaying a static mesh
class IMeshSceneNode : public ISceneNode class IMeshSceneNode : public ISceneNode
{ {
public: public:
//! Constructor //! Constructor
/** Use setMesh() to set the mesh to display. /** Use setMesh() to set the mesh to display.
*/ */
IMeshSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id, IMeshSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id,
const core::vector3df& position = core::vector3df(0,0,0), const core::vector3df &position = core::vector3df(0, 0, 0),
const core::vector3df& rotation = core::vector3df(0,0,0), const core::vector3df &rotation = core::vector3df(0, 0, 0),
const core::vector3df& scale = core::vector3df(1,1,1)) const core::vector3df &scale = core::vector3df(1, 1, 1)) :
: ISceneNode(parent, mgr, id, position, rotation, scale) {} ISceneNode(parent, mgr, id, position, rotation, scale) {}
//! Sets a new mesh to display //! Sets a new mesh to display
/** \param mesh Mesh to display. */ /** \param mesh Mesh to display. */
virtual void setMesh(IMesh* mesh) = 0; virtual void setMesh(IMesh *mesh) = 0;
//! Get the currently defined mesh for display. //! Get the currently defined mesh for display.
/** \return Pointer to mesh which is displayed by this node. */ /** \return Pointer to mesh which is displayed by this node. */
virtual IMesh* getMesh(void) = 0; virtual IMesh *getMesh(void) = 0;
//! Sets if the scene node should not copy the materials of the mesh but use them in a read only style. //! Sets if the scene node should not copy the materials of the mesh but use them in a read only style.
/** In this way it is possible to change the materials of a mesh /** In this way it is possible to change the materials of a mesh

13
include/IOSOperator.h
View File

@ -15,32 +15,31 @@ class IOSOperator : public virtual IReferenceCounted
{ {
public: public:
//! Get the current OS version as string. //! Get the current OS version as string.
virtual const core::stringc& getOperatingSystemVersion() const = 0; virtual const core::stringc &getOperatingSystemVersion() const = 0;
//! 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;
//! Copies text to the primary selection //! Copies text to the primary selection
//! This is a no-op on some platforms. //! This is a no-op on some platforms.
//! \param text: text in utf-8 //! \param text: text in utf-8
virtual void copyToPrimarySelection(const c8* text) const = 0; virtual void copyToPrimarySelection(const c8 *text) const = 0;
//! Get text from the clipboard //! Get text from the clipboard
//! \return Returns 0 if no string is in there, otherwise an utf-8 string. //! \return Returns 0 if no string is in there, otherwise an utf-8 string.
virtual const c8* getTextFromClipboard() const = 0; virtual const c8 *getTextFromClipboard() const = 0;
//! Get text from the primary selection //! Get text from the primary selection
//! This is a no-op on some platforms. //! This is a no-op on some platforms.
//! \return Returns 0 if no string is in there, otherwise an utf-8 string. //! \return Returns 0 if no string is in there, otherwise an utf-8 string.
virtual const c8* getTextFromPrimarySelection() const = 0; virtual const c8 *getTextFromPrimarySelection() const = 0;
//! Get the total and available system RAM //! Get the total and available system RAM
/** \param totalBytes: will contain the total system memory in Kilobytes (1024 B) /** \param totalBytes: will contain the total system memory in Kilobytes (1024 B)
\param availableBytes: will contain the available memory in Kilobytes (1024 B) \param availableBytes: will contain the available memory in Kilobytes (1024 B)
\return True if successful, false if not */ \return True if successful, false if not */
virtual bool getSystemMemory(u32* totalBytes, u32* availableBytes) const = 0; virtual bool getSystemMemory(u32 *totalBytes, u32 *availableBytes) const = 0;
}; };
} // end namespace } // end namespace

74
include/IReadFile.h
View File

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

270
include/IReferenceCounted.h
View File

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

181
include/IRenderTarget.h
View File

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

30
include/ISceneCollisionManager.h
View File

@ -13,23 +13,21 @@ namespace irr
namespace scene namespace scene
{ {
class ICameraSceneNode; class ICameraSceneNode;
class ISceneCollisionManager : public virtual IReferenceCounted class ISceneCollisionManager : public virtual IReferenceCounted
{ {
public: public:
//! Returns a 3d ray which would go through the 2d screen coordinates.
//! Returns a 3d ray which would go through the 2d screen coordinates. /** \param pos: Screen coordinates in pixels.
/** \param pos: Screen coordinates in pixels. \param camera: Camera from which the ray starts. If null, the
\param camera: Camera from which the ray starts. If null, the active camera is used.
active camera is used. \return Ray starting from the position of the camera and ending
\return Ray starting from the position of the camera and ending at a length of the far value of the camera at a position which
at a length of the far value of the camera at a position which would be behind the 2d screen coordinates. */
would be behind the 2d screen coordinates. */ virtual core::line3d<f32> getRayFromScreenCoordinates(
virtual core::line3d<f32> getRayFromScreenCoordinates( const core::position2d<s32> &pos, const ICameraSceneNode *camera = 0) = 0;
const core::position2d<s32>& pos, const ICameraSceneNode* camera = 0) = 0; };
};
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

1094
include/ISceneManager.h
View File

File diff suppressed because it is too large Load Diff

1132
include/ISceneNode.h
View File

File diff suppressed because it is too large Load Diff

10
include/IShaderConstantSetCallBack.h
View File

@ -10,8 +10,8 @@ namespace irr
{ {
namespace video namespace video
{ {
class IMaterialRendererServices; class IMaterialRendererServices;
class SMaterial; class SMaterial;
//! Interface making it possible to set constants for gpu programs every frame. //! Interface making it possible to set constants for gpu programs every frame.
/** Implement this interface in an own class and pass a pointer to it to one of /** Implement this interface in an own class and pass a pointer to it to one of
@ -20,7 +20,6 @@ OnSetConstants method will be called every frame now. */
class IShaderConstantSetCallBack : public virtual IReferenceCounted class IShaderConstantSetCallBack : public virtual IReferenceCounted
{ {
public: public:
//! Called to let the callBack know the used material (optional method) //! Called to let the callBack know the used material (optional method)
/** /**
\code \code
@ -40,7 +39,7 @@ public:
} }
\endcode \endcode
*/ */
virtual void OnSetMaterial(const SMaterial& material) { } virtual void OnSetMaterial(const SMaterial &material) {}
//! Called by the engine when the vertex and/or pixel shader constants for an material renderer should be set. //! Called by the engine when the vertex and/or pixel shader constants for an material renderer should be set.
/** /**
@ -73,9 +72,8 @@ public:
\param services: Pointer to an interface providing methods to set the constants for the shader. \param services: Pointer to an interface providing methods to set the constants for the shader.
\param userData: Userdata int which can be specified when creating the shader. \param userData: Userdata int which can be specified when creating the shader.
*/ */
virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData) = 0; virtual void OnSetConstants(IMaterialRendererServices *services, s32 userData) = 0;
}; };
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

387
include/ISkinnedMesh.h
View File

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

24
include/ITexture.h
View File

@ -16,7 +16,6 @@ namespace irr
namespace video namespace video
{ {
//! Enumeration flags used to tell the video driver with setTextureCreationFlag in which format textures should be created. //! Enumeration flags used to tell the video driver with setTextureCreationFlag in which format textures should be created.
enum E_TEXTURE_CREATION_FLAG enum E_TEXTURE_CREATION_FLAG
{ {
@ -66,7 +65,7 @@ enum E_TEXTURE_CREATION_FLAG
/** Discard any alpha layer and use non-alpha color format. /** Discard any alpha layer and use non-alpha color format.
Warning: This may lead to getting 24-bit texture formats which Warning: This may lead to getting 24-bit texture formats which
are often badly supported by drivers. So it's generally are often badly supported by drivers. So it's generally
not recommended to enable this flag. */ not recommended to enable this flag. */
ETCF_NO_ALPHA_CHANNEL = 0x00000020, ETCF_NO_ALPHA_CHANNEL = 0x00000020,
@ -176,10 +175,10 @@ and write a warning or an error message to the output buffer.
class ITexture : public virtual IReferenceCounted class ITexture : public virtual IReferenceCounted
{ {
public: public:
//! constructor //! constructor
ITexture(const io::path& name, E_TEXTURE_TYPE type) : NamedPath(name), DriverType(EDT_NULL), OriginalColorFormat(ECF_UNKNOWN), ITexture(const io::path &name, E_TEXTURE_TYPE type) :
ColorFormat(ECF_UNKNOWN), Pitch(0), HasMipMaps(false), IsRenderTarget(false), Source(ETS_UNKNOWN), Type(type) NamedPath(name), DriverType(EDT_NULL), OriginalColorFormat(ECF_UNKNOWN),
ColorFormat(ECF_UNKNOWN), Pitch(0), HasMipMaps(false), IsRenderTarget(false), Source(ETS_UNKNOWN), Type(type)
{ {
} }
@ -206,7 +205,7 @@ public:
\return Returns a pointer to the pixel data. The format of the pixel can \return Returns a pointer to the pixel data. The format of the pixel can
be determined by using getColorFormat(). 0 is returned, if be determined by using getColorFormat(). 0 is returned, if
the texture cannot be locked. */ the texture cannot be locked. */
virtual void* lock(E_TEXTURE_LOCK_MODE mode = ETLM_READ_WRITE, u32 mipmapLevel=0, u32 layer = 0, E_TEXTURE_LOCK_FLAGS lockFlags = ETLF_FLIP_Y_UP_RTT) = 0; virtual void *lock(E_TEXTURE_LOCK_MODE mode = ETLM_READ_WRITE, u32 mipmapLevel = 0, u32 layer = 0, E_TEXTURE_LOCK_FLAGS lockFlags = ETLF_FLIP_Y_UP_RTT) = 0;
//! Unlock function. Must be called after a lock() to the texture. //! Unlock function. Must be called after a lock() to the texture.
/** One should avoid to call unlock more than once before another lock. /** One should avoid to call unlock more than once before another lock.
@ -223,7 +222,7 @@ public:
level. At least one pixel will be always kept. level. At least one pixel will be always kept.
\param layer It informs a texture about which cubemap or texture array layer \param layer It informs a texture about which cubemap or texture array layer
needs mipmap regeneration. */ needs mipmap regeneration. */
virtual void regenerateMipMapLevels(void* data = 0, u32 layer = 0) = 0; virtual void regenerateMipMapLevels(void *data = 0, u32 layer = 0) = 0;
//! Get original size of the texture. //! Get original size of the texture.
/** The texture is usually scaled, if it was created with an unoptimal /** The texture is usually scaled, if it was created with an unoptimal
@ -233,11 +232,11 @@ public:
exact size of the original texture. Use ITexture::getSize() if you want exact size of the original texture. Use ITexture::getSize() if you want
to know the real size it has now stored in the system. to know the real size it has now stored in the system.
\return The original size of the texture. */ \return The original size of the texture. */
const core::dimension2d<u32>& getOriginalSize() const { return OriginalSize; }; const core::dimension2d<u32> &getOriginalSize() const { return OriginalSize; };
//! Get dimension (=size) of the texture. //! Get dimension (=size) of the texture.
/** \return The size of the texture. */ /** \return The size of the texture. */
const core::dimension2d<u32>& getSize() const { return Size; }; const core::dimension2d<u32> &getSize() const { return Size; };
//! Get driver type of texture. //! Get driver type of texture.
/** This is the driver, which created the texture. This method is used /** This is the driver, which created the texture. This method is used
@ -274,7 +273,7 @@ public:
bool isRenderTarget() const { return IsRenderTarget; } bool isRenderTarget() const { return IsRenderTarget; }
//! Get name of texture (in most cases this is the filename) //! Get name of texture (in most cases this is the filename)
const io::SNamedPath& getName() const { return NamedPath; } const io::SNamedPath &getName() const { return NamedPath; }
//! Check where the last IVideoDriver::getTexture found this texture //! Check where the last IVideoDriver::getTexture found this texture
E_TEXTURE_SOURCE getSource() const { return Source; } E_TEXTURE_SOURCE getSource() const { return Source; }
@ -287,8 +286,7 @@ public:
{ {
bool status = false; bool status = false;
switch (ColorFormat) switch (ColorFormat) {
{
case ECF_A8R8G8B8: case ECF_A8R8G8B8:
case ECF_A1R5G5B5: case ECF_A1R5G5B5:
case ECF_A16B16G16R16F: case ECF_A16B16G16R16F:
@ -306,7 +304,6 @@ public:
E_TEXTURE_TYPE getType() const { return Type; } E_TEXTURE_TYPE getType() const { return Type; }
protected: protected:
//! Helper function, helps to get the desired texture creation format from the flags. //! Helper function, helps to get the desired texture creation format from the flags.
/** \return Either ETCF_ALWAYS_32_BIT, ETCF_ALWAYS_16_BIT, /** \return Either ETCF_ALWAYS_32_BIT, ETCF_ALWAYS_16_BIT,
ETCF_OPTIMIZED_FOR_QUALITY, or ETCF_OPTIMIZED_FOR_SPEED. */ ETCF_OPTIMIZED_FOR_QUALITY, or ETCF_OPTIMIZED_FOR_SPEED. */
@ -336,6 +333,5 @@ protected:
E_TEXTURE_TYPE Type; E_TEXTURE_TYPE Type;
}; };
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

51
include/IVertexBuffer.h
View File

@ -14,36 +14,35 @@ namespace irr
namespace scene namespace scene
{ {
class IVertexBuffer : public virtual IReferenceCounted class IVertexBuffer : public virtual IReferenceCounted
{ {
public: public:
virtual void* getData() =0; virtual void *getData() = 0;
virtual video::E_VERTEX_TYPE getType() const =0; virtual video::E_VERTEX_TYPE getType() const = 0;
virtual void setType(video::E_VERTEX_TYPE vertexType) =0; virtual void setType(video::E_VERTEX_TYPE vertexType) = 0;
virtual u32 stride() const =0; virtual u32 stride() const = 0;
virtual u32 size() const =0; virtual u32 size() const = 0;
virtual void push_back(const video::S3DVertex &element) =0; virtual void push_back(const video::S3DVertex &element) = 0;
virtual video::S3DVertex& operator [](const u32 index) const =0; virtual video::S3DVertex &operator[](const u32 index) const = 0;
virtual video::S3DVertex& getLast() =0; virtual video::S3DVertex &getLast() = 0;
virtual void set_used(u32 usedNow) =0; virtual void set_used(u32 usedNow) = 0;
virtual void reallocate(u32 new_size) =0; virtual void reallocate(u32 new_size) = 0;
virtual u32 allocated_size() const =0; virtual u32 allocated_size() const = 0;
virtual video::S3DVertex* pointer() =0; virtual video::S3DVertex *pointer() = 0;
//! get the current hardware mapping hint //! get the current hardware mapping hint
virtual E_HARDWARE_MAPPING getHardwareMappingHint() const =0; virtual E_HARDWARE_MAPPING getHardwareMappingHint() const = 0;
//! set the hardware mapping hint, for driver //! set the hardware mapping hint, for driver
virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) =0; virtual void setHardwareMappingHint(E_HARDWARE_MAPPING NewMappingHint) = 0;
//! flags the meshbuffer as changed, reloads hardware buffers //! flags the meshbuffer as changed, reloads hardware buffers
virtual void setDirty() =0; virtual void setDirty() = 0;
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
virtual u32 getChangedID() const = 0;
};
//! Get the currently used ID for identification of changes.
/** This shouldn't be used for anything outside the VideoDriver. */
virtual u32 getChangedID() const = 0;
};
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

2268
include/IVideoDriver.h
View File

File diff suppressed because it is too large Load Diff

52
include/IWriteFile.h
View File

@ -12,36 +12,36 @@ namespace irr
namespace io namespace io
{ {
//! Interface providing write access to a file. //! Interface providing write access to a file.
class IWriteFile : public virtual IReferenceCounted class IWriteFile : public virtual IReferenceCounted
{ {
public: public:
//! Writes an amount of bytes to the file. //! Writes an amount of bytes to the file.
/** \param buffer Pointer to buffer of bytes to write. /** \param buffer Pointer to buffer of bytes to write.
\param sizeToWrite Amount of bytes to write to the file. \param sizeToWrite Amount of bytes to write to the file.
\return How much bytes were written. */ \return How much bytes were written. */
virtual size_t write(const void* buffer, size_t sizeToWrite) = 0; virtual size_t write(const void *buffer, size_t sizeToWrite) = 0;
//! Changes position in file //! Changes position in file
/** \param finalPos Destination position in the file. /** \param finalPos Destination position in the file.
\param relativeMovement If set to true, the position in the file is \param relativeMovement If set to true, the position in the file is
changed relative to current position. Otherwise the position is changed changed relative to current position. Otherwise the position is changed
from begin of file. from begin of file.
\return True if successful, otherwise false. */ \return True if successful, otherwise false. */
virtual bool seek(long finalPos, bool relativeMovement = false) = 0; virtual bool seek(long finalPos, bool relativeMovement = false) = 0;
//! Get the current position in the file. //! Get the current position in the file.
/** \return Current position in the file in bytes on success or -1L on failure */ /** \return Current position in the file in bytes on success or -1L on failure */
virtual long getPos() const = 0; virtual long getPos() const = 0;
//! Get name of file. //! Get name of file.
/** \return File name as zero terminated character string. */ /** \return File name as zero terminated character string. */
virtual const path& getFileName() const = 0; virtual const path &getFileName() const = 0;
//! Flush the content of the buffer in the file //! Flush the content of the buffer in the file
/** \return True if successful, otherwise false. */ /** \return True if successful, otherwise false. */
virtual bool flush() = 0; virtual bool flush() = 0;
}; };
} // end namespace io } // end namespace io
} // end namespace irr } // end namespace irr

543
include/IrrlichtDevice.h
View File

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

348
include/Keycodes.h
View File

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

166
include/S3DVertex.h
View File

@ -31,28 +31,29 @@ enum E_VERTEX_TYPE
}; };
//! Array holding the built in vertex type names //! Array holding the built in vertex type names
const char* const sBuiltInVertexTypeNames[] = const char *const sBuiltInVertexTypeNames[] =
{ {
"standard", "standard",
"2tcoords", "2tcoords",
"tangents", "tangents",
0 0};
};
//! standard vertex used by the Irrlicht engine. //! standard vertex used by the Irrlicht engine.
struct S3DVertex struct S3DVertex
{ {
//! default constructor //! default constructor
constexpr S3DVertex() : Color(0xffffffff) {} constexpr S3DVertex() :
Color(0xffffffff) {}
//! constructor //! constructor
constexpr S3DVertex(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv) constexpr S3DVertex(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv) :
: Pos(x,y,z), Normal(nx,ny,nz), Color(c), TCoords(tu,tv) {} Pos(x, y, z), Normal(nx, ny, nz), Color(c), TCoords(tu, tv) {}
//! constructor //! constructor
constexpr S3DVertex(const core::vector3df& pos, const core::vector3df& normal, constexpr S3DVertex(const core::vector3df &pos, const core::vector3df &normal,
SColor color, const core::vector2df& tcoords) SColor color, const core::vector2df &tcoords) :
: Pos(pos), Normal(normal), Color(color), TCoords(tcoords) {} Pos(pos),
Normal(normal), Color(color), TCoords(tcoords) {}
//! Position //! Position
core::vector3df Pos; core::vector3df Pos;
@ -66,19 +67,19 @@ struct S3DVertex
//! Texture coordinates //! Texture coordinates
core::vector2df TCoords; core::vector2df TCoords;
constexpr bool operator==(const S3DVertex& other) const constexpr bool operator==(const S3DVertex &other) const
{ {
return ((Pos == other.Pos) && (Normal == other.Normal) && return ((Pos == other.Pos) && (Normal == other.Normal) &&
(Color == other.Color) && (TCoords == other.TCoords)); (Color == other.Color) && (TCoords == other.TCoords));
} }
constexpr bool operator!=(const S3DVertex& other) const constexpr bool operator!=(const S3DVertex &other) const
{ {
return ((Pos != other.Pos) || (Normal != other.Normal) || return ((Pos != other.Pos) || (Normal != other.Normal) ||
(Color != other.Color) || (TCoords != other.TCoords)); (Color != other.Color) || (TCoords != other.TCoords));
} }
constexpr bool operator<(const S3DVertex& other) const constexpr bool operator<(const S3DVertex &other) const
{ {
return ((Pos < other.Pos) || return ((Pos < other.Pos) ||
((Pos == other.Pos) && (Normal < other.Normal)) || ((Pos == other.Pos) && (Normal < other.Normal)) ||
@ -93,7 +94,7 @@ struct S3DVertex
} }
//\param d d=0 returns other, d=1 returns this, values between interpolate. //\param d d=0 returns other, d=1 returns this, values between interpolate.
S3DVertex getInterpolated(const S3DVertex& other, f32 d) S3DVertex getInterpolated(const S3DVertex &other, f32 d)
{ {
d = core::clamp(d, 0.0f, 1.0f); d = core::clamp(d, 0.0f, 1.0f);
return S3DVertex(Pos.getInterpolated(other.Pos, d), return S3DVertex(Pos.getInterpolated(other.Pos, d),
@ -103,7 +104,6 @@ struct S3DVertex
} }
}; };
//! Vertex with two texture coordinates. //! Vertex with two texture coordinates.
/** Usually used for geometry with lightmaps /** Usually used for geometry with lightmaps
or other special materials. or other special materials.
@ -111,61 +111,68 @@ or other special materials.
struct S3DVertex2TCoords : public S3DVertex struct S3DVertex2TCoords : public S3DVertex
{ {
//! default constructor //! default constructor
constexpr S3DVertex2TCoords() : S3DVertex() {} constexpr S3DVertex2TCoords() :
S3DVertex() {}
//! constructor with two different texture coords, but no normal //! constructor with two different texture coords, but no normal
constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2) constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2) :
: S3DVertex(x,y,z, 0.0f, 0.0f, 0.0f, c, tu,tv), TCoords2(tu2,tv2) {} S3DVertex(x, y, z, 0.0f, 0.0f, 0.0f, c, tu, tv), TCoords2(tu2, tv2) {}
//! constructor with two different texture coords, but no normal //! constructor with two different texture coords, but no normal
constexpr S3DVertex2TCoords(const core::vector3df& pos, SColor color, constexpr S3DVertex2TCoords(const core::vector3df &pos, SColor color,
const core::vector2df& tcoords, const core::vector2df& tcoords2) const core::vector2df &tcoords, const core::vector2df &tcoords2) :
: S3DVertex(pos, core::vector3df(), color, tcoords), TCoords2(tcoords2) {} S3DVertex(pos, core::vector3df(), color, tcoords),
TCoords2(tcoords2) {}
//! constructor with all values //! constructor with all values
constexpr S3DVertex2TCoords(const core::vector3df& pos, const core::vector3df& normal, const SColor& color, constexpr S3DVertex2TCoords(const core::vector3df &pos, const core::vector3df &normal, const SColor &color,
const core::vector2df& tcoords, const core::vector2df& tcoords2) const core::vector2df &tcoords, const core::vector2df &tcoords2) :
: S3DVertex(pos, normal, color, tcoords), TCoords2(tcoords2) {} S3DVertex(pos, normal, color, tcoords),
TCoords2(tcoords2) {}
//! constructor with all values //! constructor with all values
constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz,
SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2) SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2) :
: S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), TCoords2(tu2,tv2) {} S3DVertex(x, y, z, nx, ny, nz, c, tu, tv),
TCoords2(tu2, tv2) {}
//! constructor with the same texture coords and normal //! constructor with the same texture coords and normal
constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz,
SColor c, f32 tu, f32 tv) SColor c, f32 tu, f32 tv) :
: S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), TCoords2(tu,tv) {} S3DVertex(x, y, z, nx, ny, nz, c, tu, tv),
TCoords2(tu, tv) {}
//! constructor with the same texture coords and normal //! constructor with the same texture coords and normal
constexpr S3DVertex2TCoords(const core::vector3df& pos, const core::vector3df& normal, constexpr S3DVertex2TCoords(const core::vector3df &pos, const core::vector3df &normal,
SColor color, const core::vector2df& tcoords) SColor color, const core::vector2df &tcoords) :
: S3DVertex(pos, normal, color, tcoords), TCoords2(tcoords) {} S3DVertex(pos, normal, color, tcoords),
TCoords2(tcoords) {}
//! constructor from S3DVertex //! constructor from S3DVertex
constexpr S3DVertex2TCoords(const S3DVertex& o) : S3DVertex(o) {} constexpr S3DVertex2TCoords(const S3DVertex &o) :
S3DVertex(o) {}
//! Second set of texture coordinates //! Second set of texture coordinates
core::vector2df TCoords2; core::vector2df TCoords2;
//! Equality operator //! Equality operator
constexpr bool operator==(const S3DVertex2TCoords& other) const constexpr bool operator==(const S3DVertex2TCoords &other) const
{ {
return ((static_cast<S3DVertex>(*this)==static_cast<const S3DVertex&>(other)) && return ((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex &>(other)) &&
(TCoords2 == other.TCoords2)); (TCoords2 == other.TCoords2));
} }
//! Inequality operator //! Inequality operator
constexpr bool operator!=(const S3DVertex2TCoords& other) const constexpr bool operator!=(const S3DVertex2TCoords &other) const
{ {
return ((static_cast<S3DVertex>(*this)!=static_cast<const S3DVertex&>(other)) || return ((static_cast<S3DVertex>(*this) != static_cast<const S3DVertex &>(other)) ||
(TCoords2 != other.TCoords2)); (TCoords2 != other.TCoords2));
} }
constexpr bool operator<(const S3DVertex2TCoords& other) const constexpr bool operator<(const S3DVertex2TCoords &other) const
{ {
return ((static_cast<S3DVertex>(*this) < other) || return ((static_cast<S3DVertex>(*this) < other) ||
((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex&>(other)) && (TCoords2 < other.TCoords2))); ((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex &>(other)) && (TCoords2 < other.TCoords2)));
} }
static E_VERTEX_TYPE getType() static E_VERTEX_TYPE getType()
@ -174,7 +181,7 @@ struct S3DVertex2TCoords : public S3DVertex
} }
//\param d d=0 returns other, d=1 returns this, values between interpolate. //\param d d=0 returns other, d=1 returns this, values between interpolate.
S3DVertex2TCoords getInterpolated(const S3DVertex2TCoords& other, f32 d) S3DVertex2TCoords getInterpolated(const S3DVertex2TCoords &other, f32 d)
{ {
d = core::clamp(d, 0.0f, 1.0f); d = core::clamp(d, 0.0f, 1.0f);
return S3DVertex2TCoords(Pos.getInterpolated(other.Pos, d), return S3DVertex2TCoords(Pos.getInterpolated(other.Pos, d),
@ -185,7 +192,6 @@ struct S3DVertex2TCoords : public S3DVertex
} }
}; };
//! Vertex with a tangent and binormal vector. //! Vertex with a tangent and binormal vector.
/** Usually used for tangent space normal mapping. /** Usually used for tangent space normal mapping.
Usually tangent and binormal get send to shaders as texture coordinate sets 1 and 2. Usually tangent and binormal get send to shaders as texture coordinate sets 1 and 2.
@ -193,30 +199,34 @@ struct S3DVertex2TCoords : public S3DVertex
struct S3DVertexTangents : public S3DVertex struct S3DVertexTangents : public S3DVertex
{ {
//! default constructor //! default constructor
S3DVertexTangents() : S3DVertex() { } S3DVertexTangents() :
S3DVertex() {}
//! constructor //! constructor
constexpr S3DVertexTangents(f32 x, f32 y, f32 z, f32 nx=0.0f, f32 ny=0.0f, f32 nz=0.0f, constexpr S3DVertexTangents(f32 x, f32 y, f32 z, f32 nx = 0.0f, f32 ny = 0.0f, f32 nz = 0.0f,
SColor c = 0xFFFFFFFF, f32 tu=0.0f, f32 tv=0.0f, SColor c = 0xFFFFFFFF, f32 tu = 0.0f, f32 tv = 0.0f,
f32 tanx=0.0f, f32 tany=0.0f, f32 tanz=0.0f, f32 tanx = 0.0f, f32 tany = 0.0f, f32 tanz = 0.0f,
f32 bx=0.0f, f32 by=0.0f, f32 bz=0.0f) f32 bx = 0.0f, f32 by = 0.0f, f32 bz = 0.0f) :
: S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), Tangent(tanx,tany,tanz), Binormal(bx,by,bz) { } S3DVertex(x, y, z, nx, ny, nz, c, tu, tv),
Tangent(tanx, tany, tanz), Binormal(bx, by, bz) {}
//! constructor //! constructor
constexpr S3DVertexTangents(const core::vector3df& pos, SColor c, constexpr S3DVertexTangents(const core::vector3df &pos, SColor c,
const core::vector2df& tcoords) const core::vector2df &tcoords) :
: S3DVertex(pos, core::vector3df(), c, tcoords) { } S3DVertex(pos, core::vector3df(), c, tcoords) {}
//! constructor //! constructor
constexpr S3DVertexTangents(const core::vector3df& pos, constexpr S3DVertexTangents(const core::vector3df &pos,
const core::vector3df& normal, SColor c, const core::vector3df &normal, SColor c,
const core::vector2df& tcoords, const core::vector2df &tcoords,
const core::vector3df& tangent=core::vector3df(), const core::vector3df &tangent = core::vector3df(),
const core::vector3df& binormal=core::vector3df()) const core::vector3df &binormal = core::vector3df()) :
: S3DVertex(pos, normal, c, tcoords), Tangent(tangent), Binormal(binormal) { } S3DVertex(pos, normal, c, tcoords),
Tangent(tangent), Binormal(binormal) {}
//! constructor from S3DVertex //! constructor from S3DVertex
constexpr S3DVertexTangents(const S3DVertex& o) : S3DVertex(o) {} constexpr S3DVertexTangents(const S3DVertex &o) :
S3DVertex(o) {}
//! Tangent vector along the x-axis of the texture //! Tangent vector along the x-axis of the texture
core::vector3df Tangent; core::vector3df Tangent;
@ -224,25 +234,25 @@ struct S3DVertexTangents : public S3DVertex
//! Binormal vector (tangent x normal) //! Binormal vector (tangent x normal)
core::vector3df Binormal; core::vector3df Binormal;
constexpr bool operator==(const S3DVertexTangents& other) const constexpr bool operator==(const S3DVertexTangents &other) const
{ {
return ((static_cast<S3DVertex>(*this)==static_cast<const S3DVertex&>(other)) && return ((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex &>(other)) &&
(Tangent == other.Tangent) && (Tangent == other.Tangent) &&
(Binormal == other.Binormal)); (Binormal == other.Binormal));
} }
constexpr bool operator!=(const S3DVertexTangents& other) const constexpr bool operator!=(const S3DVertexTangents &other) const
{ {
return ((static_cast<S3DVertex>(*this)!=static_cast<const S3DVertex&>(other)) || return ((static_cast<S3DVertex>(*this) != static_cast<const S3DVertex &>(other)) ||
(Tangent != other.Tangent) || (Tangent != other.Tangent) ||
(Binormal != other.Binormal)); (Binormal != other.Binormal));
} }
constexpr bool operator<(const S3DVertexTangents& other) const constexpr bool operator<(const S3DVertexTangents &other) const
{ {
return ((static_cast<S3DVertex>(*this) < other) || return ((static_cast<S3DVertex>(*this) < other) ||
((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex&>(other)) && (Tangent < other.Tangent)) || ((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex &>(other)) && (Tangent < other.Tangent)) ||
((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex&>(other)) && (Tangent == other.Tangent) && (Binormal < other.Binormal))); ((static_cast<S3DVertex>(*this) == static_cast<const S3DVertex &>(other)) && (Tangent == other.Tangent) && (Binormal < other.Binormal)));
} }
static E_VERTEX_TYPE getType() static E_VERTEX_TYPE getType()
@ -250,7 +260,7 @@ struct S3DVertexTangents : public S3DVertex
return EVT_TANGENTS; return EVT_TANGENTS;
} }
S3DVertexTangents getInterpolated(const S3DVertexTangents& other, f32 d) S3DVertexTangents getInterpolated(const S3DVertexTangents &other, f32 d)
{ {
d = core::clamp(d, 0.0f, 1.0f); d = core::clamp(d, 0.0f, 1.0f);
return S3DVertexTangents(Pos.getInterpolated(other.Pos, d), return S3DVertexTangents(Pos.getInterpolated(other.Pos, d),
@ -262,12 +272,9 @@ struct S3DVertexTangents : public S3DVertex
} }
}; };
inline u32 getVertexPitchFromType(E_VERTEX_TYPE vertexType) inline u32 getVertexPitchFromType(E_VERTEX_TYPE vertexType)
{ {
switch (vertexType) switch (vertexType) {
{
case video::EVT_2TCOORDS: case video::EVT_2TCOORDS:
return sizeof(video::S3DVertex2TCoords); return sizeof(video::S3DVertex2TCoords);
case video::EVT_TANGENTS: case video::EVT_TANGENTS:
@ -277,6 +284,5 @@ inline u32 getVertexPitchFromType(E_VERTEX_TYPE vertexType)
} }
} }
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

275
include/SAnimatedMesh.h
View File

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

1400
include/SColor.h
View File

File diff suppressed because it is too large Load Diff

42
include/SExposedVideoData.h
View File

@ -17,52 +17,62 @@ you are using the software or the null device.
*/ */
struct SExposedVideoData struct SExposedVideoData
{ {
SExposedVideoData() {OpenGLWin32.HDc=0; OpenGLWin32.HRc=0; OpenGLWin32.HWnd=0;} SExposedVideoData()
explicit SExposedVideoData(void* Window) {OpenGLWin32.HDc=0; OpenGLWin32.HRc=0; OpenGLWin32.HWnd=Window;} {
OpenGLWin32.HDc = 0;
OpenGLWin32.HRc = 0;
OpenGLWin32.HWnd = 0;
}
explicit SExposedVideoData(void *Window)
{
OpenGLWin32.HDc = 0;
OpenGLWin32.HRc = 0;
OpenGLWin32.HWnd = Window;
}
struct SOpenGLWin32 struct SOpenGLWin32
{ {
//! Private GDI Device Context. //! Private GDI Device Context.
/** Get if for example with: HDC h = reinterpret_cast<HDC>(exposedData.OpenGLWin32.HDc) */ /** Get if for example with: HDC h = reinterpret_cast<HDC>(exposedData.OpenGLWin32.HDc) */
void* HDc; void *HDc;
//! Permanent Rendering Context. //! Permanent Rendering Context.
/** Get if for example with: HGLRC h = reinterpret_cast<HGLRC>(exposedData.OpenGLWin32.HRc) */ /** Get if for example with: HGLRC h = reinterpret_cast<HGLRC>(exposedData.OpenGLWin32.HRc) */
void* HRc; void *HRc;
//! Window handle. //! Window handle.
/** Get with for example with: HWND h = reinterpret_cast<HWND>(exposedData.OpenGLWin32.HWnd) */ /** Get with for example with: HWND h = reinterpret_cast<HWND>(exposedData.OpenGLWin32.HWnd) */
void* HWnd; void *HWnd;
}; };
struct SOpenGLLinux struct SOpenGLLinux
{ {
// XWindow handles // XWindow handles
void* X11Display; void *X11Display;
void* X11Context; void *X11Context;
unsigned long X11Window; unsigned long X11Window;
unsigned long GLXWindow; unsigned long GLXWindow;
}; };
struct SOpenGLOSX struct SOpenGLOSX
{ {
//! The NSOpenGLContext object. //! The NSOpenGLContext object.
void* Context; void *Context;
//! The NSWindow object. //! The NSWindow object.
void* Window; void *Window;
}; };
struct SOpenGLFB struct SOpenGLFB
{ {
//! The EGLNativeWindowType object. //! The EGLNativeWindowType object.
void* Window; void *Window;
}; };
struct SOGLESAndroid struct SOGLESAndroid
{ {
//! The ANativeWindow object. //! The ANativeWindow object.
void* Window; void *Window;
}; };
union union

417
include/SIrrCreationParameters.h
View File

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

984
include/SMaterial.h
View File

File diff suppressed because it is too large Load Diff

392
include/SMaterialLayer.h
View File

@ -10,174 +10,166 @@ namespace irr
{ {
namespace video namespace video
{ {
class ITexture; class ITexture;
//! Texture coord clamp mode outside [0.0, 1.0] //! Texture coord clamp mode outside [0.0, 1.0]
enum E_TEXTURE_CLAMP enum E_TEXTURE_CLAMP
{ {
//! Texture repeats //! Texture repeats
ETC_REPEAT = 0, ETC_REPEAT = 0,
//! Texture is clamped to the last pixel //! Texture is clamped to the last pixel
ETC_CLAMP, ETC_CLAMP,
//! Texture is clamped to the edge pixel //! Texture is clamped to the edge pixel
ETC_CLAMP_TO_EDGE, ETC_CLAMP_TO_EDGE,
//! Texture is clamped to the border pixel (if exists) //! Texture is clamped to the border pixel (if exists)
ETC_CLAMP_TO_BORDER, ETC_CLAMP_TO_BORDER,
//! Texture is alternatingly mirrored (0..1..0..1..0..) //! Texture is alternatingly mirrored (0..1..0..1..0..)
ETC_MIRROR, ETC_MIRROR,
//! Texture is mirrored once and then clamped (0..1..0) //! Texture is mirrored once and then clamped (0..1..0)
ETC_MIRROR_CLAMP, ETC_MIRROR_CLAMP,
//! Texture is mirrored once and then clamped to edge //! Texture is mirrored once and then clamped to edge
ETC_MIRROR_CLAMP_TO_EDGE, ETC_MIRROR_CLAMP_TO_EDGE,
//! Texture is mirrored once and then clamped to border //! Texture is mirrored once and then clamped to border
ETC_MIRROR_CLAMP_TO_BORDER ETC_MIRROR_CLAMP_TO_BORDER
}; };
static const char* const aTextureClampNames[] = { static const char *const aTextureClampNames[] = {
"texture_clamp_repeat", "texture_clamp_repeat",
"texture_clamp_clamp", "texture_clamp_clamp",
"texture_clamp_clamp_to_edge", "texture_clamp_clamp_to_edge",
"texture_clamp_clamp_to_border", "texture_clamp_clamp_to_border",
"texture_clamp_mirror", "texture_clamp_mirror",
"texture_clamp_mirror_clamp", "texture_clamp_mirror_clamp",
"texture_clamp_mirror_clamp_to_edge", "texture_clamp_mirror_clamp_to_edge",
"texture_clamp_mirror_clamp_to_border", 0}; "texture_clamp_mirror_clamp_to_border", 0};
//! Texture minification filter.
/** Used when scaling textures down. See the documentation on OpenGL's
`GL_TEXTURE_MIN_FILTER` for more information. */
enum E_TEXTURE_MIN_FILTER
{
//! Aka nearest-neighbor.
ETMINF_NEAREST_MIPMAP_NEAREST = 0,
//! Aka bilinear.
ETMINF_LINEAR_MIPMAP_NEAREST,
//! Isn't known by any other name.
ETMINF_NEAREST_MIPMAP_LINEAR,
//! Aka trilinear.
ETMINF_LINEAR_MIPMAP_LINEAR,
};
//! Texture minification filter. //! Texture magnification filter.
/** Used when scaling textures down. See the documentation on OpenGL's /** Used when scaling textures up. See the documentation on OpenGL's
`GL_TEXTURE_MIN_FILTER` for more information. */ `GL_TEXTURE_MAG_FILTER` for more information.
enum E_TEXTURE_MIN_FILTER { Note that mipmaps are only used for minification, not for magnification. */
//! Aka nearest-neighbor. enum E_TEXTURE_MAG_FILTER
ETMINF_NEAREST_MIPMAP_NEAREST = 0, {
//! Aka bilinear. //! Aka nearest-neighbor.
ETMINF_LINEAR_MIPMAP_NEAREST, ETMAGF_NEAREST = 0,
//! Isn't known by any other name. //! Aka bilinear.
ETMINF_NEAREST_MIPMAP_LINEAR, ETMAGF_LINEAR,
//! Aka trilinear. };
ETMINF_LINEAR_MIPMAP_LINEAR,
};
//! Texture magnification filter. //! Struct for holding material parameters which exist per texture layer
/** Used when scaling textures up. See the documentation on OpenGL's // Note for implementors: Serialization is in CNullDriver
`GL_TEXTURE_MAG_FILTER` for more information. class SMaterialLayer
Note that mipmaps are only used for minification, not for magnification. */ {
enum E_TEXTURE_MAG_FILTER { public:
//! Aka nearest-neighbor. //! Default constructor
ETMAGF_NEAREST = 0, SMaterialLayer() :
//! Aka bilinear. Texture(0), TextureWrapU(ETC_REPEAT), TextureWrapV(ETC_REPEAT), TextureWrapW(ETC_REPEAT),
ETMAGF_LINEAR,
};
//! Struct for holding material parameters which exist per texture layer
// Note for implementors: Serialization is in CNullDriver
class SMaterialLayer
{
public:
//! Default constructor
SMaterialLayer() : Texture(0), TextureWrapU(ETC_REPEAT), TextureWrapV(ETC_REPEAT), TextureWrapW(ETC_REPEAT),
MinFilter(ETMINF_LINEAR_MIPMAP_NEAREST), MagFilter(ETMAGF_LINEAR), AnisotropicFilter(0), LODBias(0), TextureMatrix(0) MinFilter(ETMINF_LINEAR_MIPMAP_NEAREST), MagFilter(ETMAGF_LINEAR), AnisotropicFilter(0), LODBias(0), TextureMatrix(0)
{ {
}
//! Copy constructor
/** \param other Material layer to copy from. */
SMaterialLayer(const SMaterialLayer &other)
{
// This pointer is checked during assignment
TextureMatrix = 0;
*this = other;
}
//! Destructor
~SMaterialLayer()
{
if (TextureMatrix) {
delete TextureMatrix;
} }
}
//! Copy constructor //! Assignment operator
/** \param other Material layer to copy from. */ /** \param other Material layer to copy from.
SMaterialLayer(const SMaterialLayer& other) \return This material layer, updated. */
{ SMaterialLayer &operator=(const SMaterialLayer &other)
// This pointer is checked during assignment {
TextureMatrix = 0; // Check for self-assignment!
*this = other; if (this == &other)
}
//! Destructor
~SMaterialLayer()
{
if ( TextureMatrix )
{
delete TextureMatrix;
}
}
//! Assignment operator
/** \param other Material layer to copy from.
\return This material layer, updated. */
SMaterialLayer& operator=(const SMaterialLayer& other)
{
// Check for self-assignment!
if (this == &other)
return *this;
Texture = other.Texture;
if (TextureMatrix)
{
if (other.TextureMatrix)
*TextureMatrix = *other.TextureMatrix;
else
{
delete TextureMatrix;
TextureMatrix = 0;
}
}
else
{
if (other.TextureMatrix)
{
TextureMatrix = new core::matrix4(*other.TextureMatrix);
}
else
TextureMatrix = 0;
}
TextureWrapU = other.TextureWrapU;
TextureWrapV = other.TextureWrapV;
TextureWrapW = other.TextureWrapW;
MinFilter = other.MinFilter;
MagFilter = other.MagFilter;
AnisotropicFilter = other.AnisotropicFilter;
LODBias = other.LODBias;
return *this; return *this;
}
//! Gets the texture transformation matrix Texture = other.Texture;
/** \return Texture matrix of this layer. */ if (TextureMatrix) {
core::matrix4& getTextureMatrix() if (other.TextureMatrix)
{ *TextureMatrix = *other.TextureMatrix;
if (!TextureMatrix) else {
{ delete TextureMatrix;
TextureMatrix = new core::matrix4(); TextureMatrix = 0;
} }
} else {
if (other.TextureMatrix) {
TextureMatrix = new core::matrix4(*other.TextureMatrix);
} else
TextureMatrix = 0;
}
TextureWrapU = other.TextureWrapU;
TextureWrapV = other.TextureWrapV;
TextureWrapW = other.TextureWrapW;
MinFilter = other.MinFilter;
MagFilter = other.MagFilter;
AnisotropicFilter = other.AnisotropicFilter;
LODBias = other.LODBias;
return *this;
}
//! Gets the texture transformation matrix
/** \return Texture matrix of this layer. */
core::matrix4 &getTextureMatrix()
{
if (!TextureMatrix) {
TextureMatrix = new core::matrix4();
}
return *TextureMatrix;
}
//! Gets the immutable texture transformation matrix
/** \return Texture matrix of this layer. */
const core::matrix4 &getTextureMatrix() const
{
if (TextureMatrix)
return *TextureMatrix; return *TextureMatrix;
} else
return core::IdentityMatrix;
}
//! Gets the immutable texture transformation matrix //! Sets the texture transformation matrix to mat
/** \return Texture matrix of this layer. */ /** NOTE: Pipelines can ignore this matrix when the
const core::matrix4& getTextureMatrix() const texture is 0.
{ \param mat New texture matrix for this layer. */
if (TextureMatrix) void setTextureMatrix(const core::matrix4 &mat)
return *TextureMatrix; {
else if (!TextureMatrix) {
return core::IdentityMatrix; TextureMatrix = new core::matrix4(mat);
} } else
*TextureMatrix = mat;
}
//! Sets the texture transformation matrix to mat //! Inequality operator
/** NOTE: Pipelines can ignore this matrix when the /** \param b Layer to compare to.
texture is 0. \return True if layers are different, else false. */
\param mat New texture matrix for this layer. */ inline bool operator!=(const SMaterialLayer &b) const
void setTextureMatrix(const core::matrix4& mat) {
{ bool different =
if (!TextureMatrix)
{
TextureMatrix = new core::matrix4(mat);
}
else
*TextureMatrix = mat;
}
//! Inequality operator
/** \param b Layer to compare to.
\return True if layers are different, else false. */
inline bool operator!=(const SMaterialLayer& b) const
{
bool different =
Texture != b.Texture || Texture != b.Texture ||
TextureWrapU != b.TextureWrapU || TextureWrapU != b.TextureWrapU ||
TextureWrapV != b.TextureWrapV || TextureWrapV != b.TextureWrapV ||
@ -186,59 +178,61 @@ namespace video
MagFilter != b.MagFilter || MagFilter != b.MagFilter ||
AnisotropicFilter != b.AnisotropicFilter || AnisotropicFilter != b.AnisotropicFilter ||
LODBias != b.LODBias; LODBias != b.LODBias;
if (different) if (different)
return true; return true;
else else
different |= (TextureMatrix != b.TextureMatrix) && different |= (TextureMatrix != b.TextureMatrix) &&
(!TextureMatrix || !b.TextureMatrix || (*TextureMatrix != *(b.TextureMatrix))); (!TextureMatrix || !b.TextureMatrix || (*TextureMatrix != *(b.TextureMatrix)));
return different; return different;
} }
//! Equality operator //! Equality operator
/** \param b Layer to compare to. /** \param b Layer to compare to.
\return True if layers are equal, else false. */ \return True if layers are equal, else false. */
inline bool operator==(const SMaterialLayer& b) const inline bool operator==(const SMaterialLayer &b) const
{ return !(b!=*this); } {
return !(b != *this);
}
//! Texture //! Texture
ITexture* Texture; ITexture *Texture;
//! Texture Clamp Mode //! Texture Clamp Mode
/** Values are taken from E_TEXTURE_CLAMP. */ /** Values are taken from E_TEXTURE_CLAMP. */
u8 TextureWrapU:4; u8 TextureWrapU : 4;
u8 TextureWrapV:4; u8 TextureWrapV : 4;
u8 TextureWrapW:4; u8 TextureWrapW : 4;
//! Minification (downscaling) filter //! Minification (downscaling) filter
E_TEXTURE_MIN_FILTER MinFilter; E_TEXTURE_MIN_FILTER MinFilter;
//! Magnification (upscaling) filter //! Magnification (upscaling) filter
E_TEXTURE_MAG_FILTER MagFilter; E_TEXTURE_MAG_FILTER MagFilter;
//! Is anisotropic filtering enabled? Default: 0, disabled //! Is anisotropic filtering enabled? Default: 0, disabled
/** In Irrlicht you can use anisotropic texture filtering /** In Irrlicht you can use anisotropic texture filtering
in conjunction with bilinear or trilinear texture in conjunction with bilinear or trilinear texture
filtering to improve rendering results. Primitives filtering to improve rendering results. Primitives
will look less blurry with this flag switched on. The number gives will look less blurry with this flag switched on. The number gives
the maximal anisotropy degree, and is often in the range 2-16. the maximal anisotropy degree, and is often in the range 2-16.
Value 1 is equivalent to 0, but should be avoided. */ Value 1 is equivalent to 0, but should be avoided. */
u8 AnisotropicFilter; u8 AnisotropicFilter;
//! Bias for the mipmap choosing decision. //! Bias for the mipmap choosing decision.
/** This value can make the textures more or less blurry than with the /** This value can make the textures more or less blurry than with the
default value of 0. The value (divided by 8.f) is added to the mipmap level default value of 0. The value (divided by 8.f) is added to the mipmap level
chosen initially, and thus takes a smaller mipmap for a region chosen initially, and thus takes a smaller mipmap for a region
if the value is positive. */ if the value is positive. */
s8 LODBias; s8 LODBias;
private: private:
friend class SMaterial; friend class SMaterial;
//! Texture Matrix //! Texture Matrix
/** Do not access this element directly as the internal /** Do not access this element directly as the internal
resource management has to cope with Null pointers etc. */ resource management has to cope with Null pointers etc. */
core::matrix4* TextureMatrix; core::matrix4 *TextureMatrix;
}; };
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

208
include/SMesh.h
View File

@ -13,130 +13,120 @@ namespace irr
{ {
namespace scene namespace scene
{ {
//! Simple implementation of the IMesh interface. //! Simple implementation of the IMesh interface.
struct SMesh : public IMesh struct SMesh : public IMesh
{
//! constructor
SMesh()
{ {
//! constructor #ifdef _DEBUG
SMesh() setDebugName("SMesh");
{ #endif
#ifdef _DEBUG }
setDebugName("SMesh");
#endif //! destructor
virtual ~SMesh()
{
// drop buffers
for (u32 i = 0; i < MeshBuffers.size(); ++i)
MeshBuffers[i]->drop();
}
//! clean mesh
virtual void clear()
{
for (u32 i = 0; i < MeshBuffers.size(); ++i)
MeshBuffers[i]->drop();
MeshBuffers.clear();
BoundingBox.reset(0.f, 0.f, 0.f);
}
//! returns amount of mesh buffers.
u32 getMeshBufferCount() const override
{
return MeshBuffers.size();
}
//! returns pointer to a mesh buffer
IMeshBuffer *getMeshBuffer(u32 nr) const override
{
return MeshBuffers[nr];
}
//! returns a meshbuffer which fits a material
/** reverse search */
IMeshBuffer *getMeshBuffer(const video::SMaterial &material) const override
{
for (s32 i = (s32)MeshBuffers.size() - 1; i >= 0; --i) {
if (material == MeshBuffers[i]->getMaterial())
return MeshBuffers[i];
} }
//! destructor return 0;
virtual ~SMesh() }
{
// drop buffers
for (u32 i=0; i<MeshBuffers.size(); ++i)
MeshBuffers[i]->drop();
}
//! clean mesh //! returns an axis aligned bounding box
virtual void clear() const core::aabbox3d<f32> &getBoundingBox() const override
{ {
for (u32 i=0; i<MeshBuffers.size(); ++i) return BoundingBox;
MeshBuffers[i]->drop(); }
MeshBuffers.clear();
BoundingBox.reset ( 0.f, 0.f, 0.f );
}
//! set user axis aligned bounding box
void setBoundingBox(const core::aabbox3df &box) override
{
BoundingBox = box;
}
//! returns amount of mesh buffers. //! recalculates the bounding box
u32 getMeshBufferCount() const override void recalculateBoundingBox()
{ {
return MeshBuffers.size(); bool hasMeshBufferBBox = false;
} for (u32 i = 0; i < MeshBuffers.size(); ++i) {
const core::aabbox3df &bb = MeshBuffers[i]->getBoundingBox();
//! returns pointer to a mesh buffer if (!bb.isEmpty()) {
IMeshBuffer* getMeshBuffer(u32 nr) const override if (!hasMeshBufferBBox) {
{ hasMeshBufferBBox = true;
return MeshBuffers[nr]; BoundingBox = bb;
} } else {
BoundingBox.addInternalBox(bb);
//! returns a meshbuffer which fits a material
/** reverse search */
IMeshBuffer* getMeshBuffer( const video::SMaterial & material) const override
{
for (s32 i = (s32)MeshBuffers.size()-1; i >= 0; --i)
{
if ( material == MeshBuffers[i]->getMaterial())
return MeshBuffers[i];
}
return 0;
}
//! returns an axis aligned bounding box
const core::aabbox3d<f32>& getBoundingBox() const override
{
return BoundingBox;
}
//! set user axis aligned bounding box
void setBoundingBox( const core::aabbox3df& box) override
{
BoundingBox = box;
}
//! recalculates the bounding box
void recalculateBoundingBox()
{
bool hasMeshBufferBBox = false;
for (u32 i=0; i<MeshBuffers.size(); ++i)
{
const core::aabbox3df& bb = MeshBuffers[i]->getBoundingBox();
if ( !bb.isEmpty() )
{
if ( !hasMeshBufferBBox )
{
hasMeshBufferBBox = true;
BoundingBox = bb;
}
else
{
BoundingBox.addInternalBox(bb);
}
} }
} }
if ( !hasMeshBufferBBox )
BoundingBox.reset(0.0f, 0.0f, 0.0f);
} }
//! adds a MeshBuffer if (!hasMeshBufferBBox)
/** The bounding box is not updated automatically. */ BoundingBox.reset(0.0f, 0.0f, 0.0f);
void addMeshBuffer(IMeshBuffer* buf) }
{
if (buf) //! adds a MeshBuffer
{ /** The bounding box is not updated automatically. */
buf->grab(); void addMeshBuffer(IMeshBuffer *buf)
MeshBuffers.push_back(buf); {
} if (buf) {
buf->grab();
MeshBuffers.push_back(buf);
} }
}
//! set the hardware mapping hint, for driver //! set the hardware mapping hint, for driver
void setHardwareMappingHint( E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX ) override void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer = EBT_VERTEX_AND_INDEX) override
{ {
for (u32 i=0; i<MeshBuffers.size(); ++i) for (u32 i = 0; i < MeshBuffers.size(); ++i)
MeshBuffers[i]->setHardwareMappingHint(newMappingHint, buffer); MeshBuffers[i]->setHardwareMappingHint(newMappingHint, buffer);
} }
//! flags the meshbuffer as changed, reloads hardware buffers //! flags the meshbuffer as changed, reloads hardware buffers
void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX) override void setDirty(E_BUFFER_TYPE buffer = EBT_VERTEX_AND_INDEX) override
{ {
for (u32 i=0; i<MeshBuffers.size(); ++i) for (u32 i = 0; i < MeshBuffers.size(); ++i)
MeshBuffers[i]->setDirty(buffer); MeshBuffers[i]->setDirty(buffer);
} }
//! The meshbuffers of this mesh //! The meshbuffers of this mesh
core::array<IMeshBuffer*> MeshBuffers; core::array<IMeshBuffer *> MeshBuffers;
//! The bounding box of this mesh
core::aabbox3d<f32> BoundingBox;
};
//! The bounding box of this mesh
core::aabbox3d<f32> BoundingBox;
};
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

1
include/SMeshBuffer.h
View File

@ -4,4 +4,3 @@
// replaced by template // replaced by template
#include "CMeshBuffer.h" #include "CMeshBuffer.h"

328
include/SOverrideMaterial.h
View File

@ -11,166 +11,182 @@ namespace irr
namespace video namespace video
{ {
struct SOverrideMaterial struct SOverrideMaterial
{
//! The Material values
SMaterial Material;
//! Which values are overridden
/** OR'ed values from E_MATERIAL_PROPS. */
u32 EnableProps;
//! For those properties in EnableProps which affect layers, set which of the layers are affected
bool EnableLayerProps[MATERIAL_MAX_TEXTURES];
//! Which textures are overridden
bool EnableTextures[MATERIAL_MAX_TEXTURES];
//! Overwrite complete layers (settings of EnableLayerProps and EnableTextures don't matter then for layer data)
bool EnableLayers[MATERIAL_MAX_TEXTURES];
//! Set in which render passes the material override is active.
/** OR'ed values from E_SCENE_NODE_RENDER_PASS. */
u16 EnablePasses;
//! Global enable flag, overwritten by the SceneManager in each pass
/** NOTE: This is generally _not_ set by users of the engine, but the
Scenemanager uses the EnablePass array and sets Enabled to true if the
Override material is enabled in the current pass.
As user you generally _only_ set EnablePasses.
The exception is when rendering without SceneManager but using draw calls in the VideoDriver. */
bool Enabled;
struct SMaterialTypeReplacement
{ {
//! The Material values SMaterialTypeReplacement(s32 original, u32 replacement) :
SMaterial Material; Original(original), Replacement(replacement) {}
SMaterialTypeReplacement(u32 replacement) :
Original(-1), Replacement(replacement) {}
//! Which values are overridden //! SMaterial.MaterialType to replace.
/** OR'ed values from E_MATERIAL_PROPS. */ //! -1 for all types or a specific value to only replace that one (which is either one of E_MATERIAL_TYPE or a shader material id)
u32 EnableProps; s32 Original;
//! For those properties in EnableProps which affect layers, set which of the layers are affected
bool EnableLayerProps[MATERIAL_MAX_TEXTURES];
//! Which textures are overridden
bool EnableTextures[MATERIAL_MAX_TEXTURES];
//! Overwrite complete layers (settings of EnableLayerProps and EnableTextures don't matter then for layer data)
bool EnableLayers[MATERIAL_MAX_TEXTURES];
//! Set in which render passes the material override is active.
/** OR'ed values from E_SCENE_NODE_RENDER_PASS. */
u16 EnablePasses;
//! Global enable flag, overwritten by the SceneManager in each pass
/** NOTE: This is generally _not_ set by users of the engine, but the
Scenemanager uses the EnablePass array and sets Enabled to true if the
Override material is enabled in the current pass.
As user you generally _only_ set EnablePasses.
The exception is when rendering without SceneManager but using draw calls in the VideoDriver. */
bool Enabled;
struct SMaterialTypeReplacement
{
SMaterialTypeReplacement(s32 original, u32 replacement) : Original(original), Replacement(replacement) {}
SMaterialTypeReplacement(u32 replacement) : Original(-1), Replacement(replacement) {}
//! SMaterial.MaterialType to replace.
//! -1 for all types or a specific value to only replace that one (which is either one of E_MATERIAL_TYPE or a shader material id)
s32 Original;
//! MaterialType to used to override Original (either one of E_MATERIAL_TYPE or a shader material id)
u32 Replacement;
};
//! To overwrite SMaterial::MaterialType
core::array<SMaterialTypeReplacement> MaterialTypes;
//! Default constructor
SOverrideMaterial() : EnableProps(0), EnablePasses(0), Enabled(false)
{
}
//! disable overrides and reset all properties
void reset()
{
EnableProps = 0;
EnablePasses = 0;
Enabled = false;
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i)
{
EnableLayerProps[i] = true; // doesn't do anything unless EnableProps is set, just saying by default all texture layers are affected by properties
EnableTextures[i] = false;
EnableLayers[i] = false;
}
MaterialTypes.clear();
}
//! Apply the enabled overrides
void apply(SMaterial& material)
{
if (Enabled)
{
for (u32 i = 0; i < MaterialTypes.size(); ++i)
{
const SMaterialTypeReplacement& mtr = MaterialTypes[i];
if (mtr.Original < 0 || (s32)mtr.Original == material.MaterialType)
material.MaterialType = (E_MATERIAL_TYPE)mtr.Replacement;
}
for (u32 f=0; f<32; ++f)
{
const u32 num=(1<<f);
if (EnableProps & num)
{
switch (num)
{
case EMP_WIREFRAME: material.Wireframe = Material.Wireframe; break;
case EMP_POINTCLOUD: material.PointCloud = Material.PointCloud; break;
case EMP_GOURAUD_SHADING: material.GouraudShading = Material.GouraudShading; break;
case EMP_LIGHTING: material.Lighting = Material.Lighting; break;
case EMP_ZBUFFER: material.ZBuffer = Material.ZBuffer; break;
case EMP_ZWRITE_ENABLE: material.ZWriteEnable = Material.ZWriteEnable; break;
case EMP_BACK_FACE_CULLING: material.BackfaceCulling = Material.BackfaceCulling; break;
case EMP_FRONT_FACE_CULLING: material.FrontfaceCulling = Material.FrontfaceCulling; break;
case EMP_MIN_FILTER:
for ( u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i)
{
if ( EnableLayerProps[i] )
{
material.TextureLayers[i].MinFilter = Material.TextureLayers[i].MinFilter;
}
}
break;
case EMP_MAG_FILTER:
for ( u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i)
{
if ( EnableLayerProps[i] )
{
material.TextureLayers[i].MagFilter = Material.TextureLayers[i].MagFilter;
}
}
break;
case EMP_ANISOTROPIC_FILTER:
for ( u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i)
{
if ( EnableLayerProps[i] )
{
material.TextureLayers[i].AnisotropicFilter = Material.TextureLayers[i].AnisotropicFilter;
}
}
break;
case EMP_FOG_ENABLE: material.FogEnable = Material.FogEnable; break;
case EMP_NORMALIZE_NORMALS: material.NormalizeNormals = Material.NormalizeNormals; break;
case EMP_TEXTURE_WRAP:
for ( u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i)
{
if ( EnableLayerProps[i] )
{
material.TextureLayers[i].TextureWrapU = Material.TextureLayers[i].TextureWrapU;
material.TextureLayers[i].TextureWrapV = Material.TextureLayers[i].TextureWrapV;
material.TextureLayers[i].TextureWrapW = Material.TextureLayers[i].TextureWrapW;
}
}
break;
case EMP_ANTI_ALIASING: material.AntiAliasing = Material.AntiAliasing; break;
case EMP_COLOR_MASK: material.ColorMask = Material.ColorMask; break;
case EMP_COLOR_MATERIAL: material.ColorMaterial = Material.ColorMaterial; break;
case EMP_USE_MIP_MAPS: material.UseMipMaps = Material.UseMipMaps; break;
case EMP_BLEND_OPERATION: material.BlendOperation = Material.BlendOperation; break;
case EMP_BLEND_FACTOR: material.BlendFactor = Material.BlendFactor; break;
case EMP_POLYGON_OFFSET:
material.PolygonOffsetDepthBias = Material.PolygonOffsetDepthBias;
material.PolygonOffsetSlopeScale = Material.PolygonOffsetSlopeScale;
break;
}
}
}
for(u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i )
{
if ( EnableLayers[i] )
{
material.TextureLayers[i] = Material.TextureLayers[i];
}
else if ( EnableTextures[i] )
{
material.TextureLayers[i].Texture = Material.TextureLayers[i].Texture;
}
}
}
}
//! MaterialType to used to override Original (either one of E_MATERIAL_TYPE or a shader material id)
u32 Replacement;
}; };
//! To overwrite SMaterial::MaterialType
core::array<SMaterialTypeReplacement> MaterialTypes;
//! Default constructor
SOverrideMaterial() :
EnableProps(0), EnablePasses(0), Enabled(false)
{
}
//! disable overrides and reset all properties
void reset()
{
EnableProps = 0;
EnablePasses = 0;
Enabled = false;
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i) {
EnableLayerProps[i] = true; // doesn't do anything unless EnableProps is set, just saying by default all texture layers are affected by properties
EnableTextures[i] = false;
EnableLayers[i] = false;
}
MaterialTypes.clear();
}
//! Apply the enabled overrides
void apply(SMaterial &material)
{
if (Enabled) {
for (u32 i = 0; i < MaterialTypes.size(); ++i) {
const SMaterialTypeReplacement &mtr = MaterialTypes[i];
if (mtr.Original < 0 || (s32)mtr.Original == material.MaterialType)
material.MaterialType = (E_MATERIAL_TYPE)mtr.Replacement;
}
for (u32 f = 0; f < 32; ++f) {
const u32 num = (1 << f);
if (EnableProps & num) {
switch (num) {
case EMP_WIREFRAME:
material.Wireframe = Material.Wireframe;
break;
case EMP_POINTCLOUD:
material.PointCloud = Material.PointCloud;
break;
case EMP_GOURAUD_SHADING:
material.GouraudShading = Material.GouraudShading;
break;
case EMP_LIGHTING:
material.Lighting = Material.Lighting;
break;
case EMP_ZBUFFER:
material.ZBuffer = Material.ZBuffer;
break;
case EMP_ZWRITE_ENABLE:
material.ZWriteEnable = Material.ZWriteEnable;
break;
case EMP_BACK_FACE_CULLING:
material.BackfaceCulling = Material.BackfaceCulling;
break;
case EMP_FRONT_FACE_CULLING:
material.FrontfaceCulling = Material.FrontfaceCulling;
break;
case EMP_MIN_FILTER:
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i) {
if (EnableLayerProps[i]) {
material.TextureLayers[i].MinFilter = Material.TextureLayers[i].MinFilter;
}
}
break;
case EMP_MAG_FILTER:
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i) {
if (EnableLayerProps[i]) {
material.TextureLayers[i].MagFilter = Material.TextureLayers[i].MagFilter;
}
}
break;
case EMP_ANISOTROPIC_FILTER:
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i) {
if (EnableLayerProps[i]) {
material.TextureLayers[i].AnisotropicFilter = Material.TextureLayers[i].AnisotropicFilter;
}
}
break;
case EMP_FOG_ENABLE:
material.FogEnable = Material.FogEnable;
break;
case EMP_NORMALIZE_NORMALS:
material.NormalizeNormals = Material.NormalizeNormals;
break;
case EMP_TEXTURE_WRAP:
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i) {
if (EnableLayerProps[i]) {
material.TextureLayers[i].TextureWrapU = Material.TextureLayers[i].TextureWrapU;
material.TextureLayers[i].TextureWrapV = Material.TextureLayers[i].TextureWrapV;
material.TextureLayers[i].TextureWrapW = Material.TextureLayers[i].TextureWrapW;
}
}
break;
case EMP_ANTI_ALIASING:
material.AntiAliasing = Material.AntiAliasing;
break;
case EMP_COLOR_MASK:
material.ColorMask = Material.ColorMask;
break;
case EMP_COLOR_MATERIAL:
material.ColorMaterial = Material.ColorMaterial;
break;
case EMP_USE_MIP_MAPS:
material.UseMipMaps = Material.UseMipMaps;
break;
case EMP_BLEND_OPERATION:
material.BlendOperation = Material.BlendOperation;
break;
case EMP_BLEND_FACTOR:
material.BlendFactor = Material.BlendFactor;
break;
case EMP_POLYGON_OFFSET:
material.PolygonOffsetDepthBias = Material.PolygonOffsetDepthBias;
material.PolygonOffsetSlopeScale = Material.PolygonOffsetSlopeScale;
break;
}
}
}
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i) {
if (EnableLayers[i]) {
material.TextureLayers[i] = Material.TextureLayers[i];
} else if (EnableTextures[i]) {
material.TextureLayers[i].Texture = Material.TextureLayers[i].Texture;
}
}
}
}
};
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

355
include/SSkinMeshBuffer.h
View File

@ -7,37 +7,35 @@
#include "IMeshBuffer.h" #include "IMeshBuffer.h"
#include "S3DVertex.h" #include "S3DVertex.h"
namespace irr namespace irr
{ {
namespace scene namespace scene
{ {
//! A mesh buffer able to choose between S3DVertex2TCoords, S3DVertex and S3DVertexTangents at runtime //! A mesh buffer able to choose between S3DVertex2TCoords, S3DVertex and S3DVertexTangents at runtime
struct SSkinMeshBuffer : public IMeshBuffer struct SSkinMeshBuffer : public IMeshBuffer
{ {
//! Default constructor //! Default constructor
SSkinMeshBuffer(video::E_VERTEX_TYPE vt=video::EVT_STANDARD) : SSkinMeshBuffer(video::E_VERTEX_TYPE vt = video::EVT_STANDARD) :
ChangedID_Vertex(1), ChangedID_Index(1), VertexType(vt), ChangedID_Vertex(1), ChangedID_Index(1), VertexType(vt),
PrimitiveType(EPT_TRIANGLES), PrimitiveType(EPT_TRIANGLES),
MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER), MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER),
HWBuffer(NULL), HWBuffer(NULL),
BoundingBoxNeedsRecalculated(true) BoundingBoxNeedsRecalculated(true)
{ {
#ifdef _DEBUG #ifdef _DEBUG
setDebugName("SSkinMeshBuffer"); setDebugName("SSkinMeshBuffer");
#endif #endif
} }
//! Get Material of this buffer. //! Get Material of this buffer.
const video::SMaterial& getMaterial() const override const video::SMaterial &getMaterial() const override
{ {
return Material; return Material;
} }
//! Get Material of this buffer. //! Get Material of this buffer.
video::SMaterial& getMaterial() override video::SMaterial &getMaterial() override
{ {
return Material; return Material;
} }
@ -45,56 +43,52 @@ struct SSkinMeshBuffer : public IMeshBuffer
//! Get standard vertex at given index //! Get standard vertex at given index
virtual video::S3DVertex *getVertex(u32 index) virtual video::S3DVertex *getVertex(u32 index)
{ {
switch (VertexType) switch (VertexType) {
{ case video::EVT_2TCOORDS:
case video::EVT_2TCOORDS: return (video::S3DVertex *)&Vertices_2TCoords[index];
return (video::S3DVertex*)&Vertices_2TCoords[index]; case video::EVT_TANGENTS:
case video::EVT_TANGENTS: return (video::S3DVertex *)&Vertices_Tangents[index];
return (video::S3DVertex*)&Vertices_Tangents[index]; default:
default: return &Vertices_Standard[index];
return &Vertices_Standard[index];
} }
} }
//! Get pointer to vertex array //! Get pointer to vertex array
const void* getVertices() const override const void *getVertices() const override
{ {
switch (VertexType) switch (VertexType) {
{ case video::EVT_2TCOORDS:
case video::EVT_2TCOORDS: return Vertices_2TCoords.const_pointer();
return Vertices_2TCoords.const_pointer(); case video::EVT_TANGENTS:
case video::EVT_TANGENTS: return Vertices_Tangents.const_pointer();
return Vertices_Tangents.const_pointer(); default:
default: return Vertices_Standard.const_pointer();
return Vertices_Standard.const_pointer();
} }
} }
//! Get pointer to vertex array //! Get pointer to vertex array
void* getVertices() override void *getVertices() override
{ {
switch (VertexType) switch (VertexType) {
{ case video::EVT_2TCOORDS:
case video::EVT_2TCOORDS: return Vertices_2TCoords.pointer();
return Vertices_2TCoords.pointer(); case video::EVT_TANGENTS:
case video::EVT_TANGENTS: return Vertices_Tangents.pointer();
return Vertices_Tangents.pointer(); default:
default: return Vertices_Standard.pointer();
return Vertices_Standard.pointer();
} }
} }
//! Get vertex count //! Get vertex count
u32 getVertexCount() const override u32 getVertexCount() const override
{ {
switch (VertexType) switch (VertexType) {
{ case video::EVT_2TCOORDS:
case video::EVT_2TCOORDS: return Vertices_2TCoords.size();
return Vertices_2TCoords.size(); case video::EVT_TANGENTS:
case video::EVT_TANGENTS: return Vertices_Tangents.size();
return Vertices_Tangents.size(); default:
default: return Vertices_Standard.size();
return Vertices_Standard.size();
} }
} }
@ -106,13 +100,13 @@ struct SSkinMeshBuffer : public IMeshBuffer
} }
//! Get pointer to index array //! Get pointer to index array
const u16* getIndices() const override const u16 *getIndices() const override
{ {
return Indices.const_pointer(); return Indices.const_pointer();
} }
//! Get pointer to index array //! Get pointer to index array
u16* getIndices() override u16 *getIndices() override
{ {
return Indices.pointer(); return Indices.pointer();
} }
@ -124,13 +118,13 @@ struct SSkinMeshBuffer : public IMeshBuffer
} }
//! Get bounding box //! Get bounding box
const core::aabbox3d<f32>& getBoundingBox() const override const core::aabbox3d<f32> &getBoundingBox() const override
{ {
return BoundingBox; return BoundingBox;
} }
//! Set bounding box //! Set bounding box
void setBoundingBox( const core::aabbox3df& box) override void setBoundingBox(const core::aabbox3df &box) override
{ {
BoundingBox = box; BoundingBox = box;
} }
@ -138,49 +132,42 @@ struct SSkinMeshBuffer : public IMeshBuffer
//! Recalculate bounding box //! Recalculate bounding box
void recalculateBoundingBox() override void recalculateBoundingBox() override
{ {
if(!BoundingBoxNeedsRecalculated) if (!BoundingBoxNeedsRecalculated)
return; return;
BoundingBoxNeedsRecalculated = false; BoundingBoxNeedsRecalculated = false;
switch (VertexType) switch (VertexType) {
{ case video::EVT_STANDARD: {
case video::EVT_STANDARD: if (Vertices_Standard.empty())
{ BoundingBox.reset(0, 0, 0);
if (Vertices_Standard.empty()) else {
BoundingBox.reset(0,0,0); BoundingBox.reset(Vertices_Standard[0].Pos);
else for (u32 i = 1; i < Vertices_Standard.size(); ++i)
{ BoundingBox.addInternalPoint(Vertices_Standard[i].Pos);
BoundingBox.reset(Vertices_Standard[0].Pos);
for (u32 i=1; i<Vertices_Standard.size(); ++i)
BoundingBox.addInternalPoint(Vertices_Standard[i].Pos);
}
break;
} }
case video::EVT_2TCOORDS: break;
{ }
if (Vertices_2TCoords.empty()) case video::EVT_2TCOORDS: {
BoundingBox.reset(0,0,0); if (Vertices_2TCoords.empty())
else BoundingBox.reset(0, 0, 0);
{ else {
BoundingBox.reset(Vertices_2TCoords[0].Pos); BoundingBox.reset(Vertices_2TCoords[0].Pos);
for (u32 i=1; i<Vertices_2TCoords.size(); ++i) for (u32 i = 1; i < Vertices_2TCoords.size(); ++i)
BoundingBox.addInternalPoint(Vertices_2TCoords[i].Pos); BoundingBox.addInternalPoint(Vertices_2TCoords[i].Pos);
}
break;
} }
case video::EVT_TANGENTS: break;
{ }
if (Vertices_Tangents.empty()) case video::EVT_TANGENTS: {
BoundingBox.reset(0,0,0); if (Vertices_Tangents.empty())
else BoundingBox.reset(0, 0, 0);
{ else {
BoundingBox.reset(Vertices_Tangents[0].Pos); BoundingBox.reset(Vertices_Tangents[0].Pos);
for (u32 i=1; i<Vertices_Tangents.size(); ++i) for (u32 i = 1; i < Vertices_Tangents.size(); ++i)
BoundingBox.addInternalPoint(Vertices_Tangents[i].Pos); BoundingBox.addInternalPoint(Vertices_Tangents[i].Pos);
}
break;
} }
break;
}
} }
} }
@ -193,141 +180,128 @@ struct SSkinMeshBuffer : public IMeshBuffer
//! Convert to 2tcoords vertex type //! Convert to 2tcoords vertex type
void convertTo2TCoords() void convertTo2TCoords()
{ {
if (VertexType==video::EVT_STANDARD) if (VertexType == video::EVT_STANDARD) {
{ for (u32 n = 0; n < Vertices_Standard.size(); ++n) {
for(u32 n=0;n<Vertices_Standard.size();++n)
{
video::S3DVertex2TCoords Vertex; video::S3DVertex2TCoords Vertex;
Vertex.Color=Vertices_Standard[n].Color; Vertex.Color = Vertices_Standard[n].Color;
Vertex.Pos=Vertices_Standard[n].Pos; Vertex.Pos = Vertices_Standard[n].Pos;
Vertex.Normal=Vertices_Standard[n].Normal; Vertex.Normal = Vertices_Standard[n].Normal;
Vertex.TCoords=Vertices_Standard[n].TCoords; Vertex.TCoords = Vertices_Standard[n].TCoords;
Vertices_2TCoords.push_back(Vertex); Vertices_2TCoords.push_back(Vertex);
} }
Vertices_Standard.clear(); Vertices_Standard.clear();
VertexType=video::EVT_2TCOORDS; VertexType = video::EVT_2TCOORDS;
} }
} }
//! Convert to tangents vertex type //! Convert to tangents vertex type
void convertToTangents() void convertToTangents()
{ {
if (VertexType==video::EVT_STANDARD) if (VertexType == video::EVT_STANDARD) {
{ for (u32 n = 0; n < Vertices_Standard.size(); ++n) {
for(u32 n=0;n<Vertices_Standard.size();++n)
{
video::S3DVertexTangents Vertex; video::S3DVertexTangents Vertex;
Vertex.Color=Vertices_Standard[n].Color; Vertex.Color = Vertices_Standard[n].Color;
Vertex.Pos=Vertices_Standard[n].Pos; Vertex.Pos = Vertices_Standard[n].Pos;
Vertex.Normal=Vertices_Standard[n].Normal; Vertex.Normal = Vertices_Standard[n].Normal;
Vertex.TCoords=Vertices_Standard[n].TCoords; Vertex.TCoords = Vertices_Standard[n].TCoords;
Vertices_Tangents.push_back(Vertex); Vertices_Tangents.push_back(Vertex);
} }
Vertices_Standard.clear(); Vertices_Standard.clear();
VertexType=video::EVT_TANGENTS; VertexType = video::EVT_TANGENTS;
} } else if (VertexType == video::EVT_2TCOORDS) {
else if (VertexType==video::EVT_2TCOORDS) for (u32 n = 0; n < Vertices_2TCoords.size(); ++n) {
{
for(u32 n=0;n<Vertices_2TCoords.size();++n)
{
video::S3DVertexTangents Vertex; video::S3DVertexTangents Vertex;
Vertex.Color=Vertices_2TCoords[n].Color; Vertex.Color = Vertices_2TCoords[n].Color;
Vertex.Pos=Vertices_2TCoords[n].Pos; Vertex.Pos = Vertices_2TCoords[n].Pos;
Vertex.Normal=Vertices_2TCoords[n].Normal; Vertex.Normal = Vertices_2TCoords[n].Normal;
Vertex.TCoords=Vertices_2TCoords[n].TCoords; Vertex.TCoords = Vertices_2TCoords[n].TCoords;
Vertices_Tangents.push_back(Vertex); Vertices_Tangents.push_back(Vertex);
} }
Vertices_2TCoords.clear(); Vertices_2TCoords.clear();
VertexType=video::EVT_TANGENTS; VertexType = video::EVT_TANGENTS;
} }
} }
//! returns position of vertex i //! returns position of vertex i
const core::vector3df& getPosition(u32 i) const override const core::vector3df &getPosition(u32 i) const override
{ {
switch (VertexType) switch (VertexType) {
{ case video::EVT_2TCOORDS:
case video::EVT_2TCOORDS: return Vertices_2TCoords[i].Pos;
return Vertices_2TCoords[i].Pos; case video::EVT_TANGENTS:
case video::EVT_TANGENTS: return Vertices_Tangents[i].Pos;
return Vertices_Tangents[i].Pos; default:
default: return Vertices_Standard[i].Pos;
return Vertices_Standard[i].Pos;
} }
} }
//! returns position of vertex i //! returns position of vertex i
core::vector3df& getPosition(u32 i) override core::vector3df &getPosition(u32 i) override
{ {
switch (VertexType) switch (VertexType) {
{ case video::EVT_2TCOORDS:
case video::EVT_2TCOORDS: return Vertices_2TCoords[i].Pos;
return Vertices_2TCoords[i].Pos; case video::EVT_TANGENTS:
case video::EVT_TANGENTS: return Vertices_Tangents[i].Pos;
return Vertices_Tangents[i].Pos; default:
default: return Vertices_Standard[i].Pos;
return Vertices_Standard[i].Pos;
} }
} }
//! returns normal of vertex i //! returns normal of vertex i
const core::vector3df& getNormal(u32 i) const override const core::vector3df &getNormal(u32 i) const override
{ {
switch (VertexType) switch (VertexType) {
{ case video::EVT_2TCOORDS:
case video::EVT_2TCOORDS: return Vertices_2TCoords[i].Normal;
return Vertices_2TCoords[i].Normal; case video::EVT_TANGENTS:
case video::EVT_TANGENTS: return Vertices_Tangents[i].Normal;
return Vertices_Tangents[i].Normal; default:
default: return Vertices_Standard[i].Normal;
return Vertices_Standard[i].Normal;
} }
} }
//! returns normal of vertex i //! returns normal of vertex i
core::vector3df& getNormal(u32 i) override core::vector3df &getNormal(u32 i) override
{ {
switch (VertexType) switch (VertexType) {
{ case video::EVT_2TCOORDS:
case video::EVT_2TCOORDS: return Vertices_2TCoords[i].Normal;
return Vertices_2TCoords[i].Normal; case video::EVT_TANGENTS:
case video::EVT_TANGENTS: return Vertices_Tangents[i].Normal;
return Vertices_Tangents[i].Normal; default:
default: return Vertices_Standard[i].Normal;
return Vertices_Standard[i].Normal;
} }
} }
//! returns texture coords of vertex i //! returns texture coords of vertex i
const core::vector2df& getTCoords(u32 i) const override const core::vector2df &getTCoords(u32 i) const override
{ {
switch (VertexType) switch (VertexType) {
{ case video::EVT_2TCOORDS:
case video::EVT_2TCOORDS: return Vertices_2TCoords[i].TCoords;
return Vertices_2TCoords[i].TCoords; case video::EVT_TANGENTS:
case video::EVT_TANGENTS: return Vertices_Tangents[i].TCoords;
return Vertices_Tangents[i].TCoords; default:
default: return Vertices_Standard[i].TCoords;
return Vertices_Standard[i].TCoords;
} }
} }
//! returns texture coords of vertex i //! returns texture coords of vertex i
core::vector2df& getTCoords(u32 i) override core::vector2df &getTCoords(u32 i) override
{ {
switch (VertexType) switch (VertexType) {
{ case video::EVT_2TCOORDS:
case video::EVT_2TCOORDS: return Vertices_2TCoords[i].TCoords;
return Vertices_2TCoords[i].TCoords; case video::EVT_TANGENTS:
case video::EVT_TANGENTS: return Vertices_Tangents[i].TCoords;
return Vertices_Tangents[i].TCoords; default:
default: return Vertices_Standard[i].TCoords;
return Vertices_Standard[i].TCoords;
} }
} }
//! append the vertices and indices to the current buffer //! append the vertices and indices to the current buffer
void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) override {} void append(const void *const vertices, u32 numVertices, const u16 *const indices, u32 numIndices) override {}
//! get the current hardware mapping hint for vertex buffers //! get the current hardware mapping hint for vertex buffers
E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const override E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const override
@ -342,16 +316,15 @@ struct SSkinMeshBuffer : public IMeshBuffer
} }
//! set the hardware mapping hint, for driver //! set the hardware mapping hint, for driver
void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX ) override void setHardwareMappingHint(E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer = EBT_VERTEX_AND_INDEX) override
{ {
if (Buffer==EBT_VERTEX) if (Buffer == EBT_VERTEX)
MappingHint_Vertex=NewMappingHint; MappingHint_Vertex = NewMappingHint;
else if (Buffer==EBT_INDEX) else if (Buffer == EBT_INDEX)
MappingHint_Index=NewMappingHint; MappingHint_Index = NewMappingHint;
else if (Buffer==EBT_VERTEX_AND_INDEX) else if (Buffer == EBT_VERTEX_AND_INDEX) {
{ MappingHint_Vertex = NewMappingHint;
MappingHint_Vertex=NewMappingHint; MappingHint_Index = NewMappingHint;
MappingHint_Index=NewMappingHint;
} }
} }
@ -368,27 +341,28 @@ struct SSkinMeshBuffer : public IMeshBuffer
} }
//! flags the mesh as changed, reloads hardware buffers //! flags the mesh as changed, reloads hardware buffers
void setDirty(E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX) override void setDirty(E_BUFFER_TYPE Buffer = EBT_VERTEX_AND_INDEX) override
{ {
if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_VERTEX) if (Buffer == EBT_VERTEX_AND_INDEX || Buffer == EBT_VERTEX)
++ChangedID_Vertex; ++ChangedID_Vertex;
if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX) if (Buffer == EBT_VERTEX_AND_INDEX || Buffer == EBT_INDEX)
++ChangedID_Index; ++ChangedID_Index;
} }
u32 getChangedID_Vertex() const override {return ChangedID_Vertex;} u32 getChangedID_Vertex() const override { return ChangedID_Vertex; }
u32 getChangedID_Index() const override {return ChangedID_Index;} u32 getChangedID_Index() const override { return ChangedID_Index; }
void setHWBuffer(void *ptr) const override { void setHWBuffer(void *ptr) const override
{
HWBuffer = ptr; HWBuffer = ptr;
} }
void *getHWBuffer() const override { void *getHWBuffer() const override
{
return HWBuffer; return HWBuffer;
} }
//! Call this after changing the positions of any vertex. //! Call this after changing the positions of any vertex.
void boundingBoxNeedsRecalculated(void) { BoundingBoxNeedsRecalculated = true; } void boundingBoxNeedsRecalculated(void) { BoundingBoxNeedsRecalculated = true; }
@ -400,7 +374,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
u32 ChangedID_Vertex; u32 ChangedID_Vertex;
u32 ChangedID_Index; u32 ChangedID_Index;
//ISkinnedMesh::SJoint *AttachedJoint; // ISkinnedMesh::SJoint *AttachedJoint;
core::matrix4 Transformation; core::matrix4 Transformation;
video::SMaterial Material; video::SMaterial Material;
@ -412,14 +386,13 @@ struct SSkinMeshBuffer : public IMeshBuffer
E_PRIMITIVE_TYPE PrimitiveType; E_PRIMITIVE_TYPE PrimitiveType;
// hardware mapping hint // hardware mapping hint
E_HARDWARE_MAPPING MappingHint_Vertex:3; E_HARDWARE_MAPPING MappingHint_Vertex : 3;
E_HARDWARE_MAPPING MappingHint_Index:3; E_HARDWARE_MAPPING MappingHint_Index : 3;
mutable void *HWBuffer; mutable void *HWBuffer;
bool BoundingBoxNeedsRecalculated:1; bool BoundingBoxNeedsRecalculated : 1;
}; };
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

2
include/SVertexIndex.h
View File

@ -6,7 +6,6 @@
#include "irrTypes.h" #include "irrTypes.h"
namespace irr namespace irr
{ {
namespace video namespace video
@ -17,6 +16,5 @@ enum E_INDEX_TYPE
EIT_32BIT EIT_32BIT
}; };
} // end namespace video } // end namespace video
} // end namespace irr } // end namespace irr

44
include/SVertexManipulator.h
View File

@ -13,30 +13,32 @@ namespace irr
namespace scene namespace scene
{ {
class IMesh; class IMesh;
class IMeshBuffer; class IMeshBuffer;
struct SMesh; struct SMesh;
//! Interface for vertex manipulators. //! Interface for vertex manipulators.
/** You should derive your manipulator from this class if it shall be called for every vertex, getting as parameter just the vertex. /** You should derive your manipulator from this class if it shall be called for every vertex, getting as parameter just the vertex.
*/ */
struct IVertexManipulator struct IVertexManipulator
{ {
}; };
//! Vertex manipulator which scales the position of the vertex //! Vertex manipulator which scales the position of the vertex
class SVertexPositionScaleManipulator : public IVertexManipulator class SVertexPositionScaleManipulator : public IVertexManipulator
{
public:
SVertexPositionScaleManipulator(const core::vector3df &factor) :
Factor(factor) {}
template <typename VType>
void operator()(VType &vertex) const
{ {
public: vertex.Pos *= Factor;
SVertexPositionScaleManipulator(const core::vector3df& factor) : Factor(factor) {} }
template <typename VType>
void operator()(VType& vertex) const private:
{ core::vector3df Factor;
vertex.Pos *= Factor; };
}
private:
core::vector3df Factor;
};
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

733
include/SViewFrustum.h
View File

@ -16,443 +16,434 @@ namespace irr
namespace scene namespace scene
{ {
//! Defines the view frustum. That's the space visible by the camera. //! Defines the view frustum. That's the space visible by the camera.
/** The view frustum is enclosed by 6 planes. These six planes share /** The view frustum is enclosed by 6 planes. These six planes share
eight points. A bounding box around these eight points is also stored in eight points. A bounding box around these eight points is also stored in
this structure. this structure.
*/ */
struct SViewFrustum struct SViewFrustum
{
enum VFPLANES
{ {
enum VFPLANES //! Far plane of the frustum. That is the plane furthest away from the eye.
{ VF_FAR_PLANE = 0,
//! Far plane of the frustum. That is the plane furthest away from the eye. //! Near plane of the frustum. That is the plane nearest to the eye.
VF_FAR_PLANE = 0, VF_NEAR_PLANE,
//! Near plane of the frustum. That is the plane nearest to the eye. //! Left plane of the frustum.
VF_NEAR_PLANE, VF_LEFT_PLANE,
//! Left plane of the frustum. //! Right plane of the frustum.
VF_LEFT_PLANE, VF_RIGHT_PLANE,
//! Right plane of the frustum. //! Bottom plane of the frustum.
VF_RIGHT_PLANE, VF_BOTTOM_PLANE,
//! Bottom plane of the frustum. //! Top plane of the frustum.
VF_BOTTOM_PLANE, VF_TOP_PLANE,
//! Top plane of the frustum.
VF_TOP_PLANE,
//! Amount of planes enclosing the view frustum. Should be 6. //! Amount of planes enclosing the view frustum. Should be 6.
VF_PLANE_COUNT VF_PLANE_COUNT
};
//! Default Constructor
SViewFrustum() : BoundingRadius(0.f), FarNearDistance(0.f) {}
//! Copy Constructor
SViewFrustum(const SViewFrustum& other);
//! This constructor creates a view frustum based on a projection and/or view matrix.
//\param zClipFromZero: Clipping of z can be projected from 0 to w when true (D3D style) and from -w to w when false (OGL style).
SViewFrustum(const core::matrix4& mat, bool zClipFromZero);
//! This constructor creates a view frustum based on a projection and/or view matrix.
//\param zClipFromZero: Clipping of z can be projected from 0 to w when true (D3D style) and from -w to w when false (OGL style).
inline void setFrom(const core::matrix4& mat, bool zClipFromZero);
//! transforms the frustum by the matrix
/** \param mat: Matrix by which the view frustum is transformed.*/
void transform(const core::matrix4& mat);
//! returns the point which is on the far left upper corner inside the the view frustum.
core::vector3df getFarLeftUp() const;
//! returns the point which is on the far left bottom corner inside the the view frustum.
core::vector3df getFarLeftDown() const;
//! returns the point which is on the far right top corner inside the the view frustum.
core::vector3df getFarRightUp() const;
//! returns the point which is on the far right bottom corner inside the the view frustum.
core::vector3df getFarRightDown() const;
//! returns the point which is on the near left upper corner inside the the view frustum.
core::vector3df getNearLeftUp() const;
//! returns the point which is on the near left bottom corner inside the the view frustum.
core::vector3df getNearLeftDown() const;
//! returns the point which is on the near right top corner inside the the view frustum.
core::vector3df getNearRightUp() const;
//! returns the point which is on the near right bottom corner inside the the view frustum.
core::vector3df getNearRightDown() const;
//! returns a bounding box enclosing the whole view frustum
const core::aabbox3d<f32> &getBoundingBox() const;
//! recalculates the bounding box and sphere based on the planes
inline void recalculateBoundingBox();
//! get the bounding sphere's radius (of an optimized sphere, not the AABB's)
float getBoundingRadius() const;
//! get the bounding sphere's radius (of an optimized sphere, not the AABB's)
core::vector3df getBoundingCenter() const;
//! the cam should tell the frustum the distance between far and near
void setFarNearDistance(float distance);
//! get the given state's matrix based on frustum E_TRANSFORMATION_STATE
core::matrix4& getTransform( video::E_TRANSFORMATION_STATE state);
//! get the given state's matrix based on frustum E_TRANSFORMATION_STATE
const core::matrix4& getTransform( video::E_TRANSFORMATION_STATE state) const;
//! clips a line to the view frustum.
/** \return True if the line was clipped, false if not */
bool clipLine(core::line3d<f32>& line) const;
//! the position of the camera
core::vector3df cameraPosition;
//! all planes enclosing the view frustum.
core::plane3d<f32> planes[VF_PLANE_COUNT];
//! bounding box around the view frustum
core::aabbox3d<f32> boundingBox;
private:
//! Hold a copy of important transform matrices
enum E_TRANSFORMATION_STATE_FRUSTUM
{
ETS_VIEW = 0,
ETS_PROJECTION = 1,
ETS_COUNT_FRUSTUM
};
//! recalculates the bounding sphere based on the planes
inline void recalculateBoundingSphere();
//! Hold a copy of important transform matrices
core::matrix4 Matrices[ETS_COUNT_FRUSTUM];
float BoundingRadius;
float FarNearDistance;
core::vector3df BoundingCenter;
}; };
//! Default Constructor
SViewFrustum() :
BoundingRadius(0.f), FarNearDistance(0.f) {}
/*! //! Copy Constructor
Copy constructor ViewFrustum SViewFrustum(const SViewFrustum &other);
*/
inline SViewFrustum::SViewFrustum(const SViewFrustum& other) //! This constructor creates a view frustum based on a projection and/or view matrix.
//\param zClipFromZero: Clipping of z can be projected from 0 to w when true (D3D style) and from -w to w when false (OGL style).
SViewFrustum(const core::matrix4 &mat, bool zClipFromZero);
//! This constructor creates a view frustum based on a projection and/or view matrix.
//\param zClipFromZero: Clipping of z can be projected from 0 to w when true (D3D style) and from -w to w when false (OGL style).
inline void setFrom(const core::matrix4 &mat, bool zClipFromZero);
//! transforms the frustum by the matrix
/** \param mat: Matrix by which the view frustum is transformed.*/
void transform(const core::matrix4 &mat);
//! returns the point which is on the far left upper corner inside the the view frustum.
core::vector3df getFarLeftUp() const;
//! returns the point which is on the far left bottom corner inside the the view frustum.
core::vector3df getFarLeftDown() const;
//! returns the point which is on the far right top corner inside the the view frustum.
core::vector3df getFarRightUp() const;
//! returns the point which is on the far right bottom corner inside the the view frustum.
core::vector3df getFarRightDown() const;
//! returns the point which is on the near left upper corner inside the the view frustum.
core::vector3df getNearLeftUp() const;
//! returns the point which is on the near left bottom corner inside the the view frustum.
core::vector3df getNearLeftDown() const;
//! returns the point which is on the near right top corner inside the the view frustum.
core::vector3df getNearRightUp() const;
//! returns the point which is on the near right bottom corner inside the the view frustum.
core::vector3df getNearRightDown() const;
//! returns a bounding box enclosing the whole view frustum
const core::aabbox3d<f32> &getBoundingBox() const;
//! recalculates the bounding box and sphere based on the planes
inline void recalculateBoundingBox();
//! get the bounding sphere's radius (of an optimized sphere, not the AABB's)
float getBoundingRadius() const;
//! get the bounding sphere's radius (of an optimized sphere, not the AABB's)
core::vector3df getBoundingCenter() const;
//! the cam should tell the frustum the distance between far and near
void setFarNearDistance(float distance);
//! get the given state's matrix based on frustum E_TRANSFORMATION_STATE
core::matrix4 &getTransform(video::E_TRANSFORMATION_STATE state);
//! get the given state's matrix based on frustum E_TRANSFORMATION_STATE
const core::matrix4 &getTransform(video::E_TRANSFORMATION_STATE state) const;
//! clips a line to the view frustum.
/** \return True if the line was clipped, false if not */
bool clipLine(core::line3d<f32> &line) const;
//! the position of the camera
core::vector3df cameraPosition;
//! all planes enclosing the view frustum.
core::plane3d<f32> planes[VF_PLANE_COUNT];
//! bounding box around the view frustum
core::aabbox3d<f32> boundingBox;
private:
//! Hold a copy of important transform matrices
enum E_TRANSFORMATION_STATE_FRUSTUM
{ {
cameraPosition=other.cameraPosition; ETS_VIEW = 0,
boundingBox=other.boundingBox; ETS_PROJECTION = 1,
ETS_COUNT_FRUSTUM
};
u32 i; //! recalculates the bounding sphere based on the planes
for (i=0; i<VF_PLANE_COUNT; ++i) inline void recalculateBoundingSphere();
planes[i]=other.planes[i];
for (i=0; i<ETS_COUNT_FRUSTUM; ++i) //! Hold a copy of important transform matrices
Matrices[i]=other.Matrices[i]; core::matrix4 Matrices[ETS_COUNT_FRUSTUM];
BoundingRadius = other.BoundingRadius; float BoundingRadius;
FarNearDistance = other.FarNearDistance; float FarNearDistance;
BoundingCenter = other.BoundingCenter; core::vector3df BoundingCenter;
} };
inline SViewFrustum::SViewFrustum(const core::matrix4& mat, bool zClipFromZero) /*!
{ Copy constructor ViewFrustum
setFrom(mat, zClipFromZero); */
} inline SViewFrustum::SViewFrustum(const SViewFrustum &other)
{
cameraPosition = other.cameraPosition;
boundingBox = other.boundingBox;
u32 i;
for (i = 0; i < VF_PLANE_COUNT; ++i)
planes[i] = other.planes[i];
inline void SViewFrustum::transform(const core::matrix4& mat) for (i = 0; i < ETS_COUNT_FRUSTUM; ++i)
{ Matrices[i] = other.Matrices[i];
for (u32 i=0; i<VF_PLANE_COUNT; ++i)
mat.transformPlane(planes[i]);
mat.transformVect(cameraPosition); BoundingRadius = other.BoundingRadius;
recalculateBoundingBox(); FarNearDistance = other.FarNearDistance;
} BoundingCenter = other.BoundingCenter;
}
inline SViewFrustum::SViewFrustum(const core::matrix4 &mat, bool zClipFromZero)
{
setFrom(mat, zClipFromZero);
}
inline core::vector3df SViewFrustum::getFarLeftUp() const inline void SViewFrustum::transform(const core::matrix4 &mat)
{ {
core::vector3df p; for (u32 i = 0; i < VF_PLANE_COUNT; ++i)
planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes( mat.transformPlane(planes[i]);
mat.transformVect(cameraPosition);
recalculateBoundingBox();
}
inline core::vector3df SViewFrustum::getFarLeftUp() const
{
core::vector3df p;
planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
planes[scene::SViewFrustum::VF_TOP_PLANE], planes[scene::SViewFrustum::VF_TOP_PLANE],
planes[scene::SViewFrustum::VF_LEFT_PLANE], p); planes[scene::SViewFrustum::VF_LEFT_PLANE], p);
return p; return p;
} }
inline core::vector3df SViewFrustum::getFarLeftDown() const inline core::vector3df SViewFrustum::getFarLeftDown() const
{ {
core::vector3df p; core::vector3df p;
planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes( planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
planes[scene::SViewFrustum::VF_BOTTOM_PLANE], planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
planes[scene::SViewFrustum::VF_LEFT_PLANE], p); planes[scene::SViewFrustum::VF_LEFT_PLANE], p);
return p; return p;
} }
inline core::vector3df SViewFrustum::getFarRightUp() const inline core::vector3df SViewFrustum::getFarRightUp() const
{ {
core::vector3df p; core::vector3df p;
planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes( planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
planes[scene::SViewFrustum::VF_TOP_PLANE], planes[scene::SViewFrustum::VF_TOP_PLANE],
planes[scene::SViewFrustum::VF_RIGHT_PLANE], p); planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);
return p; return p;
} }
inline core::vector3df SViewFrustum::getFarRightDown() const inline core::vector3df SViewFrustum::getFarRightDown() const
{ {
core::vector3df p; core::vector3df p;
planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes( planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
planes[scene::SViewFrustum::VF_BOTTOM_PLANE], planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
planes[scene::SViewFrustum::VF_RIGHT_PLANE], p); planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);
return p; return p;
} }
inline core::vector3df SViewFrustum::getNearLeftUp() const inline core::vector3df SViewFrustum::getNearLeftUp() const
{ {
core::vector3df p; core::vector3df p;
planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes( planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
planes[scene::SViewFrustum::VF_TOP_PLANE], planes[scene::SViewFrustum::VF_TOP_PLANE],
planes[scene::SViewFrustum::VF_LEFT_PLANE], p); planes[scene::SViewFrustum::VF_LEFT_PLANE], p);
return p; return p;
} }
inline core::vector3df SViewFrustum::getNearLeftDown() const inline core::vector3df SViewFrustum::getNearLeftDown() const
{ {
core::vector3df p; core::vector3df p;
planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes( planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
planes[scene::SViewFrustum::VF_BOTTOM_PLANE], planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
planes[scene::SViewFrustum::VF_LEFT_PLANE], p); planes[scene::SViewFrustum::VF_LEFT_PLANE], p);
return p; return p;
} }
inline core::vector3df SViewFrustum::getNearRightUp() const inline core::vector3df SViewFrustum::getNearRightUp() const
{ {
core::vector3df p; core::vector3df p;
planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes( planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
planes[scene::SViewFrustum::VF_TOP_PLANE], planes[scene::SViewFrustum::VF_TOP_PLANE],
planes[scene::SViewFrustum::VF_RIGHT_PLANE], p); planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);
return p; return p;
} }
inline core::vector3df SViewFrustum::getNearRightDown() const inline core::vector3df SViewFrustum::getNearRightDown() const
{ {
core::vector3df p; core::vector3df p;
planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes( planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
planes[scene::SViewFrustum::VF_BOTTOM_PLANE], planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
planes[scene::SViewFrustum::VF_RIGHT_PLANE], p); planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);
return p; return p;
} }
inline const core::aabbox3d<f32> &SViewFrustum::getBoundingBox() const inline const core::aabbox3d<f32> &SViewFrustum::getBoundingBox() const
{ {
return boundingBox; return boundingBox;
} }
inline void SViewFrustum::recalculateBoundingBox() inline void SViewFrustum::recalculateBoundingBox()
{ {
boundingBox.reset(getNearLeftUp()); boundingBox.reset(getNearLeftUp());
boundingBox.addInternalPoint(getNearRightUp()); boundingBox.addInternalPoint(getNearRightUp());
boundingBox.addInternalPoint(getNearLeftDown()); boundingBox.addInternalPoint(getNearLeftDown());
boundingBox.addInternalPoint(getNearRightDown()); boundingBox.addInternalPoint(getNearRightDown());
boundingBox.addInternalPoint(getFarRightUp()); boundingBox.addInternalPoint(getFarRightUp());
boundingBox.addInternalPoint(getFarLeftDown()); boundingBox.addInternalPoint(getFarLeftDown());
boundingBox.addInternalPoint(getFarRightDown()); boundingBox.addInternalPoint(getFarRightDown());
boundingBox.addInternalPoint(getFarLeftUp()); boundingBox.addInternalPoint(getFarLeftUp());
// Also recalculate the bounding sphere when the bbox changes // Also recalculate the bounding sphere when the bbox changes
recalculateBoundingSphere(); recalculateBoundingSphere();
} }
inline float SViewFrustum::getBoundingRadius() const inline float SViewFrustum::getBoundingRadius() const
{ {
return BoundingRadius; return BoundingRadius;
} }
inline core::vector3df SViewFrustum::getBoundingCenter() const inline core::vector3df SViewFrustum::getBoundingCenter() const
{ {
return BoundingCenter; return BoundingCenter;
} }
inline void SViewFrustum::setFarNearDistance(float distance) inline void SViewFrustum::setFarNearDistance(float distance)
{ {
FarNearDistance = distance; FarNearDistance = distance;
} }
//! This constructor creates a view frustum based on a projection //! This constructor creates a view frustum based on a projection
//! and/or view matrix. //! and/or view matrix.
inline void SViewFrustum::setFrom(const core::matrix4& mat, bool zClipFromZero) inline void SViewFrustum::setFrom(const core::matrix4 &mat, bool zClipFromZero)
{ {
// left clipping plane // left clipping plane
planes[VF_LEFT_PLANE].Normal.X = mat[3 ] + mat[0]; planes[VF_LEFT_PLANE].Normal.X = mat[3] + mat[0];
planes[VF_LEFT_PLANE].Normal.Y = mat[7 ] + mat[4]; planes[VF_LEFT_PLANE].Normal.Y = mat[7] + mat[4];
planes[VF_LEFT_PLANE].Normal.Z = mat[11] + mat[8]; planes[VF_LEFT_PLANE].Normal.Z = mat[11] + mat[8];
planes[VF_LEFT_PLANE].D = mat[15] + mat[12]; planes[VF_LEFT_PLANE].D = mat[15] + mat[12];
// right clipping plane // right clipping plane
planes[VF_RIGHT_PLANE].Normal.X = mat[3 ] - mat[0]; planes[VF_RIGHT_PLANE].Normal.X = mat[3] - mat[0];
planes[VF_RIGHT_PLANE].Normal.Y = mat[7 ] - mat[4]; planes[VF_RIGHT_PLANE].Normal.Y = mat[7] - mat[4];
planes[VF_RIGHT_PLANE].Normal.Z = mat[11] - mat[8]; planes[VF_RIGHT_PLANE].Normal.Z = mat[11] - mat[8];
planes[VF_RIGHT_PLANE].D = mat[15] - mat[12]; planes[VF_RIGHT_PLANE].D = mat[15] - mat[12];
// top clipping plane // top clipping plane
planes[VF_TOP_PLANE].Normal.X = mat[3 ] - mat[1]; planes[VF_TOP_PLANE].Normal.X = mat[3] - mat[1];
planes[VF_TOP_PLANE].Normal.Y = mat[7 ] - mat[5]; planes[VF_TOP_PLANE].Normal.Y = mat[7] - mat[5];
planes[VF_TOP_PLANE].Normal.Z = mat[11] - mat[9]; planes[VF_TOP_PLANE].Normal.Z = mat[11] - mat[9];
planes[VF_TOP_PLANE].D = mat[15] - mat[13]; planes[VF_TOP_PLANE].D = mat[15] - mat[13];
// bottom clipping plane // bottom clipping plane
planes[VF_BOTTOM_PLANE].Normal.X = mat[3 ] + mat[1]; planes[VF_BOTTOM_PLANE].Normal.X = mat[3] + mat[1];
planes[VF_BOTTOM_PLANE].Normal.Y = mat[7 ] + mat[5]; planes[VF_BOTTOM_PLANE].Normal.Y = mat[7] + mat[5];
planes[VF_BOTTOM_PLANE].Normal.Z = mat[11] + mat[9]; planes[VF_BOTTOM_PLANE].Normal.Z = mat[11] + mat[9];
planes[VF_BOTTOM_PLANE].D = mat[15] + mat[13]; planes[VF_BOTTOM_PLANE].D = mat[15] + mat[13];
// far clipping plane // far clipping plane
planes[VF_FAR_PLANE].Normal.X = mat[3 ] - mat[2]; planes[VF_FAR_PLANE].Normal.X = mat[3] - mat[2];
planes[VF_FAR_PLANE].Normal.Y = mat[7 ] - mat[6]; planes[VF_FAR_PLANE].Normal.Y = mat[7] - mat[6];
planes[VF_FAR_PLANE].Normal.Z = mat[11] - mat[10]; planes[VF_FAR_PLANE].Normal.Z = mat[11] - mat[10];
planes[VF_FAR_PLANE].D = mat[15] - mat[14]; planes[VF_FAR_PLANE].D = mat[15] - mat[14];
// near clipping plane
if (zClipFromZero) {
planes[VF_NEAR_PLANE].Normal.X = mat[2];
planes[VF_NEAR_PLANE].Normal.Y = mat[6];
planes[VF_NEAR_PLANE].Normal.Z = mat[10];
planes[VF_NEAR_PLANE].D = mat[14];
} else {
// near clipping plane // near clipping plane
if ( zClipFromZero ) planes[VF_NEAR_PLANE].Normal.X = mat[3] + mat[2];
{ planes[VF_NEAR_PLANE].Normal.Y = mat[7] + mat[6];
planes[VF_NEAR_PLANE].Normal.X = mat[2]; planes[VF_NEAR_PLANE].Normal.Z = mat[11] + mat[10];
planes[VF_NEAR_PLANE].Normal.Y = mat[6]; planes[VF_NEAR_PLANE].D = mat[15] + mat[14];
planes[VF_NEAR_PLANE].Normal.Z = mat[10];
planes[VF_NEAR_PLANE].D = mat[14];
}
else
{
// near clipping plane
planes[VF_NEAR_PLANE].Normal.X = mat[3 ] + mat[2];
planes[VF_NEAR_PLANE].Normal.Y = mat[7 ] + mat[6];
planes[VF_NEAR_PLANE].Normal.Z = mat[11] + mat[10];
planes[VF_NEAR_PLANE].D = mat[15] + mat[14];
}
// normalize normals
u32 i;
for ( i=0; i != VF_PLANE_COUNT; ++i)
{
const f32 len = -core::reciprocal_squareroot(
planes[i].Normal.getLengthSQ());
planes[i].Normal *= len;
planes[i].D *= len;
}
// make bounding box
recalculateBoundingBox();
} }
/*! // normalize normals
View Frustum depends on Projection & View Matrix u32 i;
*/ for (i = 0; i != VF_PLANE_COUNT; ++i) {
inline core::matrix4& SViewFrustum::getTransform(video::E_TRANSFORMATION_STATE state) const f32 len = -core::reciprocal_squareroot(
{ planes[i].Normal.getLengthSQ());
u32 index = 0; planes[i].Normal *= len;
switch ( state ) planes[i].D *= len;
{
case video::ETS_PROJECTION:
index = SViewFrustum::ETS_PROJECTION; break;
case video::ETS_VIEW:
index = SViewFrustum::ETS_VIEW; break;
default:
break;
}
return Matrices [ index ];
} }
/*! // make bounding box
View Frustum depends on Projection & View Matrix recalculateBoundingBox();
*/ }
inline const core::matrix4& SViewFrustum::getTransform(video::E_TRANSFORMATION_STATE state) const
{ /*!
u32 index = 0; View Frustum depends on Projection & View Matrix
switch ( state ) */
{ inline core::matrix4 &SViewFrustum::getTransform(video::E_TRANSFORMATION_STATE state)
case video::ETS_PROJECTION: {
index = SViewFrustum::ETS_PROJECTION; break; u32 index = 0;
case video::ETS_VIEW: switch (state) {
index = SViewFrustum::ETS_VIEW; break; case video::ETS_PROJECTION:
default: index = SViewFrustum::ETS_PROJECTION;
break; break;
case video::ETS_VIEW:
index = SViewFrustum::ETS_VIEW;
break;
default:
break;
}
return Matrices[index];
}
/*!
View Frustum depends on Projection & View Matrix
*/
inline const core::matrix4 &SViewFrustum::getTransform(video::E_TRANSFORMATION_STATE state) const
{
u32 index = 0;
switch (state) {
case video::ETS_PROJECTION:
index = SViewFrustum::ETS_PROJECTION;
break;
case video::ETS_VIEW:
index = SViewFrustum::ETS_VIEW;
break;
default:
break;
}
return Matrices[index];
}
//! Clips a line to the frustum
inline bool SViewFrustum::clipLine(core::line3d<f32> &line) const
{
bool wasClipped = false;
for (u32 i = 0; i < VF_PLANE_COUNT; ++i) {
if (planes[i].classifyPointRelation(line.start) == core::ISREL3D_FRONT) {
line.start = line.start.getInterpolated(line.end,
1.f - planes[i].getKnownIntersectionWithLine(line.start, line.end));
wasClipped = true;
} }
return Matrices [ index ]; if (planes[i].classifyPointRelation(line.end) == core::ISREL3D_FRONT) {
line.end = line.start.getInterpolated(line.end,
1.f - planes[i].getKnownIntersectionWithLine(line.start, line.end));
wasClipped = true;
}
}
return wasClipped;
}
inline void SViewFrustum::recalculateBoundingSphere()
{
// Find the center
const float shortlen = (getNearLeftUp() - getNearRightUp()).getLength();
const float longlen = (getFarLeftUp() - getFarRightUp()).getLength();
const float farlen = FarNearDistance;
const float fartocenter = (farlen + (shortlen - longlen) * (shortlen + longlen) / (4 * farlen)) / 2;
const float neartocenter = farlen - fartocenter;
BoundingCenter = cameraPosition + -planes[VF_NEAR_PLANE].Normal * neartocenter;
// Find the radius
core::vector3df dir[8];
dir[0] = getFarLeftUp() - BoundingCenter;
dir[1] = getFarRightUp() - BoundingCenter;
dir[2] = getFarLeftDown() - BoundingCenter;
dir[3] = getFarRightDown() - BoundingCenter;
dir[4] = getNearRightDown() - BoundingCenter;
dir[5] = getNearLeftDown() - BoundingCenter;
dir[6] = getNearRightUp() - BoundingCenter;
dir[7] = getNearLeftUp() - BoundingCenter;
u32 i = 0;
float diam[8] = {0.f};
for (i = 0; i < 8; ++i)
diam[i] = dir[i].getLengthSQ();
float longest = 0;
for (i = 0; i < 8; ++i) {
if (diam[i] > longest)
longest = diam[i];
} }
//! Clips a line to the frustum BoundingRadius = sqrtf(longest);
inline bool SViewFrustum::clipLine(core::line3d<f32>& line) const }
{
bool wasClipped = false;
for (u32 i=0; i < VF_PLANE_COUNT; ++i)
{
if (planes[i].classifyPointRelation(line.start) == core::ISREL3D_FRONT)
{
line.start = line.start.getInterpolated(line.end,
1.f-planes[i].getKnownIntersectionWithLine(line.start, line.end));
wasClipped = true;
}
if (planes[i].classifyPointRelation(line.end) == core::ISREL3D_FRONT)
{
line.end = line.start.getInterpolated(line.end,
1.f-planes[i].getKnownIntersectionWithLine(line.start, line.end));
wasClipped = true;
}
}
return wasClipped;
}
inline void SViewFrustum::recalculateBoundingSphere()
{
// Find the center
const float shortlen = (getNearLeftUp() - getNearRightUp()).getLength();
const float longlen = (getFarLeftUp() - getFarRightUp()).getLength();
const float farlen = FarNearDistance;
const float fartocenter = (farlen + (shortlen - longlen) * (shortlen + longlen)/(4*farlen)) / 2;
const float neartocenter = farlen - fartocenter;
BoundingCenter = cameraPosition + -planes[VF_NEAR_PLANE].Normal * neartocenter;
// Find the radius
core::vector3df dir[8];
dir[0] = getFarLeftUp() - BoundingCenter;
dir[1] = getFarRightUp() - BoundingCenter;
dir[2] = getFarLeftDown() - BoundingCenter;
dir[3] = getFarRightDown() - BoundingCenter;
dir[4] = getNearRightDown() - BoundingCenter;
dir[5] = getNearLeftDown() - BoundingCenter;
dir[6] = getNearRightUp() - BoundingCenter;
dir[7] = getNearLeftUp() - BoundingCenter;
u32 i = 0;
float diam[8] = { 0.f };
for (i = 0; i < 8; ++i)
diam[i] = dir[i].getLengthSQ();
float longest = 0;
for (i = 0; i < 8; ++i)
{
if (diam[i] > longest)
longest = diam[i];
}
BoundingRadius = sqrtf(longest);
}
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

53
include/SceneParameters.h
View File

@ -17,35 +17,34 @@ namespace irr
{ {
namespace scene namespace scene
{ {
//! Name of the parameter for changing how Irrlicht handles the ZWrite flag for transparent (blending) materials //! Name of the parameter for changing how Irrlicht handles the ZWrite flag for transparent (blending) materials
/** The default behavior in Irrlicht is to disable writing to the /** The default behavior in Irrlicht is to disable writing to the
z-buffer for all really transparent, i.e. blending materials. This z-buffer for all really transparent, i.e. blending materials. This
avoids problems with intersecting faces, but can also break renderings. avoids problems with intersecting faces, but can also break renderings.
If transparent materials should use the SMaterial flag for ZWriteEnable If transparent materials should use the SMaterial flag for ZWriteEnable
just as other material types use this attribute. just as other material types use this attribute.
Use it like this: Use it like this:
\code \code
SceneManager->getParameters()->setAttribute(scene::ALLOW_ZWRITE_ON_TRANSPARENT, true); SceneManager->getParameters()->setAttribute(scene::ALLOW_ZWRITE_ON_TRANSPARENT, true);
\endcode \endcode
**/ **/
const c8* const ALLOW_ZWRITE_ON_TRANSPARENT = "Allow_ZWrite_On_Transparent"; const c8 *const ALLOW_ZWRITE_ON_TRANSPARENT = "Allow_ZWrite_On_Transparent";
//! Flag to avoid loading group structures in .obj files //! Flag to avoid loading group structures in .obj files
/** Use it like this: /** Use it like this:
\code \code
SceneManager->getParameters()->setAttribute(scene::OBJ_LOADER_IGNORE_GROUPS, true); SceneManager->getParameters()->setAttribute(scene::OBJ_LOADER_IGNORE_GROUPS, true);
\endcode \endcode
**/ **/
const c8* const OBJ_LOADER_IGNORE_GROUPS = "OBJ_IgnoreGroups"; const c8 *const OBJ_LOADER_IGNORE_GROUPS = "OBJ_IgnoreGroups";
//! Flag to avoid loading material .mtl file for .obj files
//! Flag to avoid loading material .mtl file for .obj files /** Use it like this:
/** Use it like this: \code
\code SceneManager->getParameters()->setAttribute(scene::OBJ_LOADER_IGNORE_MATERIAL_FILES, true);
SceneManager->getParameters()->setAttribute(scene::OBJ_LOADER_IGNORE_MATERIAL_FILES, true); \endcode
\endcode **/
**/ const c8 *const OBJ_LOADER_IGNORE_MATERIAL_FILES = "OBJ_IgnoreMaterialFiles";
const c8* const OBJ_LOADER_IGNORE_MATERIAL_FILES = "OBJ_IgnoreMaterialFiles";
} // end namespace scene } // end namespace scene
} // end namespace irr } // end namespace irr

635
include/aabbox3d.h
View File

@ -15,354 +15,375 @@ namespace core
//! Axis aligned bounding box in 3d dimensional space. //! Axis aligned bounding box in 3d dimensional space.
/** Has some useful methods used with occlusion culling or clipping. /** Has some useful methods used with occlusion culling or clipping.
*/ */
template <class T> template <class T>
class aabbox3d class aabbox3d
{ {
public: public:
//! Default Constructor.
//! Default Constructor. constexpr aabbox3d() :
constexpr aabbox3d(): MinEdge(-1,-1,-1), MaxEdge(1,1,1) {} MinEdge(-1, -1, -1), MaxEdge(1, 1, 1) {}
//! Constructor with min edge and max edge. //! Constructor with min edge and max edge.
constexpr aabbox3d(const vector3d<T>& min, const vector3d<T>& max): MinEdge(min), MaxEdge(max) {} constexpr aabbox3d(const vector3d<T> &min, const vector3d<T> &max) :
//! Constructor with only one point. MinEdge(min), MaxEdge(max) {}
constexpr aabbox3d(const vector3d<T>& init): MinEdge(init), MaxEdge(init) {} //! Constructor with only one point.
//! Constructor with min edge and max edge as single values, not vectors. constexpr aabbox3d(const vector3d<T> &init) :
constexpr aabbox3d(T minx, T miny, T minz, T maxx, T maxy, T maxz): MinEdge(init), MaxEdge(init) {}
//! Constructor with min edge and max edge as single values, not vectors.
constexpr aabbox3d(T minx, T miny, T minz, T maxx, T maxy, T maxz) :
MinEdge(minx, miny, minz), MaxEdge(maxx, maxy, maxz) {} MinEdge(minx, miny, minz), MaxEdge(maxx, maxy, maxz) {}
// operators // operators
//! Equality operator //! Equality operator
/** \param other box to compare with. /** \param other box to compare with.
\return True if both boxes are equal, else false. */ \return True if both boxes are equal, else false. */
constexpr inline bool operator==(const aabbox3d<T>& other) const constexpr inline bool operator==(const aabbox3d<T> &other) const
{ return (MinEdge == other.MinEdge && other.MaxEdge == MaxEdge); } {
//! Inequality operator return (MinEdge == other.MinEdge && other.MaxEdge == MaxEdge);
/** \param other box to compare with. }
\return True if both boxes are different, else false. */ //! Inequality operator
constexpr inline bool operator!=(const aabbox3d<T>& other) const /** \param other box to compare with.
{ return !(MinEdge == other.MinEdge && other.MaxEdge == MaxEdge); } \return True if both boxes are different, else false. */
constexpr inline bool operator!=(const aabbox3d<T> &other) const
{
return !(MinEdge == other.MinEdge && other.MaxEdge == MaxEdge);
}
// functions // functions
//! Resets the bounding box to a one-point box. //! Resets the bounding box to a one-point box.
/** \param x X coord of the point. /** \param x X coord of the point.
\param y Y coord of the point. \param y Y coord of the point.
\param z Z coord of the point. */ \param z Z coord of the point. */
void reset(T x, T y, T z) void reset(T x, T y, T z)
{ {
MaxEdge.set(x,y,z); MaxEdge.set(x, y, z);
MinEdge = MaxEdge; MinEdge = MaxEdge;
}
//! Resets the bounding box.
/** \param initValue New box to set this one to. */
void reset(const aabbox3d<T> &initValue)
{
*this = initValue;
}
//! Resets the bounding box to a one-point box.
/** \param initValue New point. */
void reset(const vector3d<T> &initValue)
{
MaxEdge = initValue;
MinEdge = initValue;
}
//! Adds a point to the bounding box
/** The box grows bigger, if point was outside of the box.
\param p: Point to add into the box. */
void addInternalPoint(const vector3d<T> &p)
{
addInternalPoint(p.X, p.Y, p.Z);
}
//! Adds another bounding box
/** The box grows bigger, if the new box was outside of the box.
\param b: Other bounding box to add into this box. */
void addInternalBox(const aabbox3d<T> &b)
{
addInternalPoint(b.MaxEdge);
addInternalPoint(b.MinEdge);
}
//! Adds a point to the bounding box
/** The box grows bigger, if point is outside of the box.
\param x X coordinate of the point to add to this box.
\param y Y coordinate of the point to add to this box.
\param z Z coordinate of the point to add to this box. */
void addInternalPoint(T x, T y, T z)
{
if (x > MaxEdge.X)
MaxEdge.X = x;
if (y > MaxEdge.Y)
MaxEdge.Y = y;
if (z > MaxEdge.Z)
MaxEdge.Z = z;
if (x < MinEdge.X)
MinEdge.X = x;
if (y < MinEdge.Y)
MinEdge.Y = y;
if (z < MinEdge.Z)
MinEdge.Z = z;
}
//! Get center of the bounding box
/** \return Center of the bounding box. */
vector3d<T> getCenter() const
{
return (MinEdge + MaxEdge) / 2;
}
//! Get extent of the box (maximal distance of two points in the box)
/** \return Extent of the bounding box. */
vector3d<T> getExtent() const
{
return MaxEdge - MinEdge;
}
//! Get radius of the bounding sphere
/** \return Radius of the bounding sphere. */
T getRadius() const
{
const T radius = getExtent().getLength() / 2;
return radius;
}
//! Check if the box is empty.
/** This means that there is no space between the min and max edge.
\return True if box is empty, else false. */
bool isEmpty() const
{
return MinEdge.equals(MaxEdge);
}
//! Get the volume enclosed by the box in cubed units
T getVolume() const
{
const vector3d<T> e = getExtent();
return e.X * e.Y * e.Z;
}
//! Get the surface area of the box in squared units
T getArea() const
{
const vector3d<T> e = getExtent();
return 2 * (e.X * e.Y + e.X * e.Z + e.Y * e.Z);
}
//! Stores all 8 edges of the box into an array
/** \param edges: Pointer to array of 8 edges. */
void getEdges(vector3d<T> *edges) const
{
const core::vector3d<T> middle = getCenter();
const core::vector3d<T> diag = middle - MaxEdge;
/*
Edges are stored in this way:
Hey, am I an ascii artist, or what? :) niko.
/3--------/7
/ | / |
/ | / |
1---------5 |
| /2- - -|- -6
| / | /
|/ | /
0---------4/
*/
edges[0].set(middle.X + diag.X, middle.Y + diag.Y, middle.Z + diag.Z);
edges[1].set(middle.X + diag.X, middle.Y - diag.Y, middle.Z + diag.Z);
edges[2].set(middle.X + diag.X, middle.Y + diag.Y, middle.Z - diag.Z);
edges[3].set(middle.X + diag.X, middle.Y - diag.Y, middle.Z - diag.Z);
edges[4].set(middle.X - diag.X, middle.Y + diag.Y, middle.Z + diag.Z);
edges[5].set(middle.X - diag.X, middle.Y - diag.Y, middle.Z + diag.Z);
edges[6].set(middle.X - diag.X, middle.Y + diag.Y, middle.Z - diag.Z);
edges[7].set(middle.X - diag.X, middle.Y - diag.Y, middle.Z - diag.Z);
}
//! Repairs the box.
/** Necessary if for example MinEdge and MaxEdge are swapped. */
void repair()
{
T t;
if (MinEdge.X > MaxEdge.X) {
t = MinEdge.X;
MinEdge.X = MaxEdge.X;
MaxEdge.X = t;
} }
if (MinEdge.Y > MaxEdge.Y) {
//! Resets the bounding box. t = MinEdge.Y;
/** \param initValue New box to set this one to. */ MinEdge.Y = MaxEdge.Y;
void reset(const aabbox3d<T>& initValue) MaxEdge.Y = t;
{
*this = initValue;
} }
if (MinEdge.Z > MaxEdge.Z) {
//! Resets the bounding box to a one-point box. t = MinEdge.Z;
/** \param initValue New point. */ MinEdge.Z = MaxEdge.Z;
void reset(const vector3d<T>& initValue) MaxEdge.Z = t;
{
MaxEdge = initValue;
MinEdge = initValue;
} }
}
//! Adds a point to the bounding box // Check if MaxEdge > MinEdge
/** The box grows bigger, if point was outside of the box. bool isValid() const
\param p: Point to add into the box. */ {
void addInternalPoint(const vector3d<T>& p) if (MinEdge.X > MaxEdge.X)
{ return false;
addInternalPoint(p.X, p.Y, p.Z); if (MinEdge.Y > MaxEdge.Y)
} return false;
if (MinEdge.Z > MaxEdge.Z)
return false;
//! Adds another bounding box return true;
/** The box grows bigger, if the new box was outside of the box. }
\param b: Other bounding box to add into this box. */
void addInternalBox(const aabbox3d<T>& b)
{
addInternalPoint(b.MaxEdge);
addInternalPoint(b.MinEdge);
}
//! Adds a point to the bounding box //! Calculates a new interpolated bounding box.
/** The box grows bigger, if point is outside of the box. /** d=0 returns other, d=1 returns this, all other values blend between
\param x X coordinate of the point to add to this box. the two boxes.
\param y Y coordinate of the point to add to this box. \param other Other box to interpolate between
\param z Z coordinate of the point to add to this box. */ \param d Value between 0.0f and 1.0f.
void addInternalPoint(T x, T y, T z) \return Interpolated box. */
{ aabbox3d<T> getInterpolated(const aabbox3d<T> &other, f32 d) const
if (x>MaxEdge.X) MaxEdge.X = x; {
if (y>MaxEdge.Y) MaxEdge.Y = y; f32 inv = 1.0f - d;
if (z>MaxEdge.Z) MaxEdge.Z = z; return aabbox3d<T>((other.MinEdge * inv) + (MinEdge * d),
(other.MaxEdge * inv) + (MaxEdge * d));
}
if (x<MinEdge.X) MinEdge.X = x; //! Determines if a point is within this box.
if (y<MinEdge.Y) MinEdge.Y = y; /** Border is included (IS part of the box)!
if (z<MinEdge.Z) MinEdge.Z = z; \param p: Point to check.
} \return True if the point is within the box and false if not */
bool isPointInside(const vector3d<T> &p) const
//! Get center of the bounding box {
/** \return Center of the bounding box. */ return (p.X >= MinEdge.X && p.X <= MaxEdge.X &&
vector3d<T> getCenter() const
{
return (MinEdge + MaxEdge) / 2;
}
//! Get extent of the box (maximal distance of two points in the box)
/** \return Extent of the bounding box. */
vector3d<T> getExtent() const
{
return MaxEdge - MinEdge;
}
//! Get radius of the bounding sphere
/** \return Radius of the bounding sphere. */
T getRadius() const
{
const T radius = getExtent().getLength() / 2;
return radius;
}
//! Check if the box is empty.
/** This means that there is no space between the min and max edge.
\return True if box is empty, else false. */
bool isEmpty() const
{
return MinEdge.equals ( MaxEdge );
}
//! Get the volume enclosed by the box in cubed units
T getVolume() const
{
const vector3d<T> e = getExtent();
return e.X * e.Y * e.Z;
}
//! Get the surface area of the box in squared units
T getArea() const
{
const vector3d<T> e = getExtent();
return 2*(e.X*e.Y + e.X*e.Z + e.Y*e.Z);
}
//! Stores all 8 edges of the box into an array
/** \param edges: Pointer to array of 8 edges. */
void getEdges(vector3d<T> *edges) const
{
const core::vector3d<T> middle = getCenter();
const core::vector3d<T> diag = middle - MaxEdge;
/*
Edges are stored in this way:
Hey, am I an ascii artist, or what? :) niko.
/3--------/7
/ | / |
/ | / |
1---------5 |
| /2- - -|- -6
| / | /
|/ | /
0---------4/
*/
edges[0].set(middle.X + diag.X, middle.Y + diag.Y, middle.Z + diag.Z);
edges[1].set(middle.X + diag.X, middle.Y - diag.Y, middle.Z + diag.Z);
edges[2].set(middle.X + diag.X, middle.Y + diag.Y, middle.Z - diag.Z);
edges[3].set(middle.X + diag.X, middle.Y - diag.Y, middle.Z - diag.Z);
edges[4].set(middle.X - diag.X, middle.Y + diag.Y, middle.Z + diag.Z);
edges[5].set(middle.X - diag.X, middle.Y - diag.Y, middle.Z + diag.Z);
edges[6].set(middle.X - diag.X, middle.Y + diag.Y, middle.Z - diag.Z);
edges[7].set(middle.X - diag.X, middle.Y - diag.Y, middle.Z - diag.Z);
}
//! Repairs the box.
/** Necessary if for example MinEdge and MaxEdge are swapped. */
void repair()
{
T t;
if (MinEdge.X > MaxEdge.X)
{ t=MinEdge.X; MinEdge.X = MaxEdge.X; MaxEdge.X=t; }
if (MinEdge.Y > MaxEdge.Y)
{ t=MinEdge.Y; MinEdge.Y = MaxEdge.Y; MaxEdge.Y=t; }
if (MinEdge.Z > MaxEdge.Z)
{ t=MinEdge.Z; MinEdge.Z = MaxEdge.Z; MaxEdge.Z=t; }
}
// Check if MaxEdge > MinEdge
bool isValid() const
{
if (MinEdge.X > MaxEdge.X) return false;
if (MinEdge.Y > MaxEdge.Y) return false;
if (MinEdge.Z > MaxEdge.Z) return false;
return true;
}
//! Calculates a new interpolated bounding box.
/** d=0 returns other, d=1 returns this, all other values blend between
the two boxes.
\param other Other box to interpolate between
\param d Value between 0.0f and 1.0f.
\return Interpolated box. */
aabbox3d<T> getInterpolated(const aabbox3d<T>& other, f32 d) const
{
f32 inv = 1.0f - d;
return aabbox3d<T>((other.MinEdge*inv) + (MinEdge*d),
(other.MaxEdge*inv) + (MaxEdge*d));
}
//! Determines if a point is within this box.
/** Border is included (IS part of the box)!
\param p: Point to check.
\return True if the point is within the box and false if not */
bool isPointInside(const vector3d<T>& p) const
{
return (p.X >= MinEdge.X && p.X <= MaxEdge.X &&
p.Y >= MinEdge.Y && p.Y <= MaxEdge.Y && p.Y >= MinEdge.Y && p.Y <= MaxEdge.Y &&
p.Z >= MinEdge.Z && p.Z <= MaxEdge.Z); p.Z >= MinEdge.Z && p.Z <= MaxEdge.Z);
} }
//! Determines if a point is within this box and not its borders. //! Determines if a point is within this box and not its borders.
/** Border is excluded (NOT part of the box)! /** Border is excluded (NOT part of the box)!
\param p: Point to check. \param p: Point to check.
\return True if the point is within the box and false if not. */ \return True if the point is within the box and false if not. */
bool isPointTotalInside(const vector3d<T>& p) const bool isPointTotalInside(const vector3d<T> &p) const
{ {
return (p.X > MinEdge.X && p.X < MaxEdge.X && return (p.X > MinEdge.X && p.X < MaxEdge.X &&
p.Y > MinEdge.Y && p.Y < MaxEdge.Y && p.Y > MinEdge.Y && p.Y < MaxEdge.Y &&
p.Z > MinEdge.Z && p.Z < MaxEdge.Z); p.Z > MinEdge.Z && p.Z < MaxEdge.Z);
} }
//! Check if this box is completely inside the 'other' box. //! Check if this box is completely inside the 'other' box.
/** \param other: Other box to check against. /** \param other: Other box to check against.
\return True if this box is completely inside the other box, \return True if this box is completely inside the other box,
otherwise false. */ otherwise false. */
bool isFullInside(const aabbox3d<T>& other) const bool isFullInside(const aabbox3d<T> &other) const
{ {
return (MinEdge.X >= other.MinEdge.X && MinEdge.Y >= other.MinEdge.Y && MinEdge.Z >= other.MinEdge.Z && return (MinEdge.X >= other.MinEdge.X && MinEdge.Y >= other.MinEdge.Y && MinEdge.Z >= other.MinEdge.Z &&
MaxEdge.X <= other.MaxEdge.X && MaxEdge.Y <= other.MaxEdge.Y && MaxEdge.Z <= other.MaxEdge.Z); MaxEdge.X <= other.MaxEdge.X && MaxEdge.Y <= other.MaxEdge.Y && MaxEdge.Z <= other.MaxEdge.Z);
} }
//! Returns the intersection of this box with another, if possible. //! Returns the intersection of this box with another, if possible.
aabbox3d<T> intersect(const aabbox3d<T>& other) const aabbox3d<T> intersect(const aabbox3d<T> &other) const
{ {
aabbox3d<T> out; aabbox3d<T> out;
if (!intersectsWithBox(other))
return out;
out.MaxEdge.X = min_(MaxEdge.X, other.MaxEdge.X);
out.MaxEdge.Y = min_(MaxEdge.Y, other.MaxEdge.Y);
out.MaxEdge.Z = min_(MaxEdge.Z, other.MaxEdge.Z);
out.MinEdge.X = max_(MinEdge.X, other.MinEdge.X);
out.MinEdge.Y = max_(MinEdge.Y, other.MinEdge.Y);
out.MinEdge.Z = max_(MinEdge.Z, other.MinEdge.Z);
if (!intersectsWithBox(other))
return out; return out;
}
//! Determines if the axis-aligned box intersects with another axis-aligned box. out.MaxEdge.X = min_(MaxEdge.X, other.MaxEdge.X);
/** \param other: Other box to check a intersection with. out.MaxEdge.Y = min_(MaxEdge.Y, other.MaxEdge.Y);
\return True if there is an intersection with the other box, out.MaxEdge.Z = min_(MaxEdge.Z, other.MaxEdge.Z);
otherwise false. */
bool intersectsWithBox(const aabbox3d<T>& other) const out.MinEdge.X = max_(MinEdge.X, other.MinEdge.X);
{ out.MinEdge.Y = max_(MinEdge.Y, other.MinEdge.Y);
return (MinEdge.X <= other.MaxEdge.X && MinEdge.Y <= other.MaxEdge.Y && MinEdge.Z <= other.MaxEdge.Z && out.MinEdge.Z = max_(MinEdge.Z, other.MinEdge.Z);
return out;
}
//! Determines if the axis-aligned box intersects with another axis-aligned box.
/** \param other: Other box to check a intersection with.
\return True if there is an intersection with the other box,
otherwise false. */
bool intersectsWithBox(const aabbox3d<T> &other) const
{
return (MinEdge.X <= other.MaxEdge.X && MinEdge.Y <= other.MaxEdge.Y && MinEdge.Z <= other.MaxEdge.Z &&
MaxEdge.X >= other.MinEdge.X && MaxEdge.Y >= other.MinEdge.Y && MaxEdge.Z >= other.MinEdge.Z); MaxEdge.X >= other.MinEdge.X && MaxEdge.Y >= other.MinEdge.Y && MaxEdge.Z >= other.MinEdge.Z);
} }
//! Tests if the box intersects with a line //! Tests if the box intersects with a line
/** \param line: Line to test intersection with. /** \param line: Line to test intersection with.
\return True if there is an intersection , else false. */ \return True if there is an intersection , else false. */
bool intersectsWithLine(const line3d<T>& line) const bool intersectsWithLine(const line3d<T> &line) const
{ {
return intersectsWithLine(line.getMiddle(), line.getVector().normalize(), return intersectsWithLine(line.getMiddle(), line.getVector().normalize(),
(T)(line.getLength() * 0.5)); (T)(line.getLength() * 0.5));
} }
//! Tests if the box intersects with a line //! Tests if the box intersects with a line
/** \param linemiddle Center of the line. /** \param linemiddle Center of the line.
\param linevect Vector of the line. \param linevect Vector of the line.
\param halflength Half length of the line. \param halflength Half length of the line.
\return True if there is an intersection, else false. */ \return True if there is an intersection, else false. */
bool intersectsWithLine(const vector3d<T>& linemiddle, bool intersectsWithLine(const vector3d<T> &linemiddle,
const vector3d<T>& linevect, T halflength) const const vector3d<T> &linevect, T halflength) const
{ {
const vector3d<T> e = getExtent() * (T)0.5; const vector3d<T> e = getExtent() * (T)0.5;
const vector3d<T> t = getCenter() - linemiddle; const vector3d<T> t = getCenter() - linemiddle;
if ((fabs(t.X) > e.X + halflength * fabs(linevect.X)) || if ((fabs(t.X) > e.X + halflength * fabs(linevect.X)) ||
(fabs(t.Y) > e.Y + halflength * fabs(linevect.Y)) || (fabs(t.Y) > e.Y + halflength * fabs(linevect.Y)) ||
(fabs(t.Z) > e.Z + halflength * fabs(linevect.Z)) ) (fabs(t.Z) > e.Z + halflength * fabs(linevect.Z)))
return false; return false;
T r = e.Y * (T)fabs(linevect.Z) + e.Z * (T)fabs(linevect.Y); T r = e.Y * (T)fabs(linevect.Z) + e.Z * (T)fabs(linevect.Y);
if (fabs(t.Y*linevect.Z - t.Z*linevect.Y) > r ) if (fabs(t.Y * linevect.Z - t.Z * linevect.Y) > r)
return false; return false;
r = e.X * (T)fabs(linevect.Z) + e.Z * (T)fabs(linevect.X); r = e.X * (T)fabs(linevect.Z) + e.Z * (T)fabs(linevect.X);
if (fabs(t.Z*linevect.X - t.X*linevect.Z) > r ) if (fabs(t.Z * linevect.X - t.X * linevect.Z) > r)
return false; return false;
r = e.X * (T)fabs(linevect.Y) + e.Y * (T)fabs(linevect.X); r = e.X * (T)fabs(linevect.Y) + e.Y * (T)fabs(linevect.X);
if (fabs(t.X*linevect.Y - t.Y*linevect.X) > r) if (fabs(t.X * linevect.Y - t.Y * linevect.X) > r)
return false; return false;
return true; return true;
}
//! Classifies a relation with a plane.
/** \param plane Plane to classify relation to.
\return Returns ISREL3D_FRONT if the box is in front of the plane,
ISREL3D_BACK if the box is behind the plane, and
ISREL3D_CLIPPED if it is on both sides of the plane. */
EIntersectionRelation3D classifyPlaneRelation(const plane3d<T> &plane) const
{
vector3d<T> nearPoint(MaxEdge);
vector3d<T> farPoint(MinEdge);
if (plane.Normal.X > (T)0) {
nearPoint.X = MinEdge.X;
farPoint.X = MaxEdge.X;
} }
//! Classifies a relation with a plane. if (plane.Normal.Y > (T)0) {
/** \param plane Plane to classify relation to. nearPoint.Y = MinEdge.Y;
\return Returns ISREL3D_FRONT if the box is in front of the plane, farPoint.Y = MaxEdge.Y;
ISREL3D_BACK if the box is behind the plane, and
ISREL3D_CLIPPED if it is on both sides of the plane. */
EIntersectionRelation3D classifyPlaneRelation(const plane3d<T>& plane) const
{
vector3d<T> nearPoint(MaxEdge);
vector3d<T> farPoint(MinEdge);
if (plane.Normal.X > (T)0)
{
nearPoint.X = MinEdge.X;
farPoint.X = MaxEdge.X;
}
if (plane.Normal.Y > (T)0)
{
nearPoint.Y = MinEdge.Y;
farPoint.Y = MaxEdge.Y;
}
if (plane.Normal.Z > (T)0)
{
nearPoint.Z = MinEdge.Z;
farPoint.Z = MaxEdge.Z;
}
if (plane.Normal.dotProduct(nearPoint) + plane.D > (T)0)
return ISREL3D_FRONT;
if (plane.Normal.dotProduct(farPoint) + plane.D > (T)0)
return ISREL3D_CLIPPED;
return ISREL3D_BACK;
} }
//! The near edge if (plane.Normal.Z > (T)0) {
vector3d<T> MinEdge; nearPoint.Z = MinEdge.Z;
farPoint.Z = MaxEdge.Z;
}
//! The far edge if (plane.Normal.dotProduct(nearPoint) + plane.D > (T)0)
vector3d<T> MaxEdge; return ISREL3D_FRONT;
if (plane.Normal.dotProduct(farPoint) + plane.D > (T)0)
return ISREL3D_CLIPPED;
return ISREL3D_BACK;
}
//! The near edge
vector3d<T> MinEdge;
//! The far edge
vector3d<T> MaxEdge;
}; };
//! Typedef for a f32 3d bounding box. //! Typedef for a f32 3d bounding box.
typedef aabbox3d<f32> aabbox3df; typedef aabbox3d<f32> aabbox3df;
//! Typedef for an integer 3d bounding box. //! Typedef for an integer 3d bounding box.
typedef aabbox3d<s32> aabbox3di; typedef aabbox3d<s32> aabbox3di;
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr

141
include/coreutil.h
View File

@ -19,62 +19,61 @@ namespace core
// ----------- some basic quite often used string functions ----------------- // ----------- some basic quite often used string functions -----------------
//! search if a filename has a proper extension //! search if a filename has a proper extension
inline s32 isFileExtension (const io::path& filename, const io::path& ext0, inline s32 isFileExtension(const io::path &filename, const io::path &ext0,
const io::path& ext1, const io::path& ext2) const io::path &ext1, const io::path &ext2)
{ {
s32 extPos = filename.findLast ( '.' ); s32 extPos = filename.findLast('.');
if ( extPos < 0 ) if (extPos < 0)
return 0; return 0;
extPos += 1; extPos += 1;
if ( filename.equals_substring_ignore_case ( ext0, extPos ) ) if (filename.equals_substring_ignore_case(ext0, extPos))
return 1; return 1;
if ( filename.equals_substring_ignore_case ( ext1, extPos ) ) if (filename.equals_substring_ignore_case(ext1, extPos))
return 2; return 2;
if ( filename.equals_substring_ignore_case ( ext2, extPos ) ) if (filename.equals_substring_ignore_case(ext2, extPos))
return 3; return 3;
return 0; return 0;
} }
//! search if a filename has a proper extension //! search if a filename has a proper extension
inline bool hasFileExtension(const io::path& filename, const io::path& ext0, inline bool hasFileExtension(const io::path &filename, const io::path &ext0,
const io::path& ext1 = "", const io::path& ext2 = "") const io::path &ext1 = "", const io::path &ext2 = "")
{ {
return isFileExtension ( filename, ext0, ext1, ext2 ) > 0; return isFileExtension(filename, ext0, ext1, ext2) > 0;
} }
//! cut the filename extension from a source file path and store it in a dest file path //! cut the filename extension from a source file path and store it in a dest file path
inline io::path& cutFilenameExtension ( io::path &dest, const io::path &source ) inline io::path &cutFilenameExtension(io::path &dest, const io::path &source)
{ {
s32 endPos = source.findLast ( '.' ); s32 endPos = source.findLast('.');
dest = source.subString ( 0, endPos < 0 ? source.size () : endPos ); dest = source.subString(0, endPos < 0 ? source.size() : endPos);
return dest; return dest;
} }
//! get the filename extension from a file path //! get the filename extension from a file path
inline io::path& getFileNameExtension ( io::path &dest, const io::path &source ) inline io::path &getFileNameExtension(io::path &dest, const io::path &source)
{ {
s32 endPos = source.findLast ( '.' ); s32 endPos = source.findLast('.');
if ( endPos < 0 ) if (endPos < 0)
dest = ""; dest = "";
else else
dest = source.subString ( endPos, source.size () ); dest = source.subString(endPos, source.size());
return dest; return dest;
} }
//! delete path from filename //! delete path from filename
inline io::path& deletePathFromFilename(io::path& filename) inline io::path &deletePathFromFilename(io::path &filename)
{ {
// delete path from filename // delete path from filename
const fschar_t* s = filename.c_str(); const fschar_t *s = filename.c_str();
const fschar_t* p = s + filename.size(); const fschar_t *p = s + filename.size();
// search for path separator or beginning // search for path separator or beginning
while ( *p != '/' && *p != '\\' && p != s ) while (*p != '/' && *p != '\\' && p != s)
p--; p--;
if ( p != s ) if (p != s) {
{
++p; ++p;
filename = p; filename = p;
} }
@ -82,51 +81,45 @@ inline io::path& deletePathFromFilename(io::path& filename)
} }
//! trim paths //! trim paths
inline io::path& deletePathFromPath(io::path& filename, s32 pathCount) inline io::path &deletePathFromPath(io::path &filename, s32 pathCount)
{ {
// delete path from filename // delete path from filename
s32 i = filename.size(); s32 i = filename.size();
// search for path separator or beginning // search for path separator or beginning
while ( i>=0 ) while (i >= 0) {
{ if (filename[i] == '/' || filename[i] == '\\') {
if ( filename[i] == '/' || filename[i] == '\\' ) if (--pathCount <= 0)
{
if ( --pathCount <= 0 )
break; break;
} }
--i; --i;
} }
if ( i>0 ) if (i > 0) {
{ filename[i + 1] = 0;
filename [ i + 1 ] = 0;
filename.validate(); filename.validate();
} } else
else filename = "";
filename="";
return filename; return filename;
} }
//! looks if file is in the same directory of path. returns offset of directory. //! looks if file is in the same directory of path. returns offset of directory.
//! 0 means in same directory. 1 means file is direct child of path //! 0 means in same directory. 1 means file is direct child of path
inline s32 isInSameDirectory ( const io::path& path, const io::path& file ) inline s32 isInSameDirectory(const io::path &path, const io::path &file)
{ {
if ( path.size() && !path.equalsn ( file, path.size() ) ) if (path.size() && !path.equalsn(file, path.size()))
return -1; return -1;
s32 subA = 0; s32 subA = 0;
s32 subB = 0; s32 subB = 0;
s32 pos = 0; s32 pos = 0;
while ( (pos = path.findNext ( '/', pos )) >= 0 ) while ((pos = path.findNext('/', pos)) >= 0) {
{
subA += 1; subA += 1;
pos += 1; pos += 1;
} }
pos = 0; pos = 0;
while ( (pos = file.findNext ( '/', pos )) >= 0 ) while ((pos = file.findNext('/', pos)) >= 0) {
{
subB += 1; subB += 1;
pos += 1; pos += 1;
} }
@ -135,55 +128,47 @@ inline s32 isInSameDirectory ( const io::path& path, const io::path& file )
} }
//! splits a path into components //! splits a path into components
static inline void splitFilename(const io::path &name, io::path* path=0, static inline void splitFilename(const io::path &name, io::path *path = 0,
io::path* filename=0, io::path* extension=0, bool make_lower=false) io::path *filename = 0, io::path *extension = 0, bool make_lower = false)
{ {
s32 i = name.size(); s32 i = name.size();
s32 extpos = i; s32 extpos = i;
// search for path separator or beginning // search for path separator or beginning
while ( i >= 0 ) while (i >= 0) {
{ if (name[i] == '.') {
if ( name[i] == '.' )
{
extpos = i; extpos = i;
if ( extension ) if (extension)
*extension = name.subString ( extpos + 1, name.size() - (extpos + 1), make_lower ); *extension = name.subString(extpos + 1, name.size() - (extpos + 1), make_lower);
} } else if (name[i] == '/' || name[i] == '\\') {
else if (filename)
if ( name[i] == '/' || name[i] == '\\' ) *filename = name.subString(i + 1, extpos - (i + 1), make_lower);
{ if (path) {
if ( filename ) *path = name.subString(0, i + 1, make_lower);
*filename = name.subString ( i + 1, extpos - (i + 1), make_lower ); path->replace('\\', '/');
if ( path )
{
*path = name.subString ( 0, i + 1, make_lower );
path->replace ( '\\', '/' );
} }
return; return;
} }
i -= 1; i -= 1;
} }
if ( filename ) if (filename)
*filename = name.subString ( 0, extpos, make_lower ); *filename = name.subString(0, extpos, make_lower);
} }
//! create a filename from components //! create a filename from components
static inline io::path mergeFilename(const io::path& path, const io::path& filename, const io::path& extension = "") static inline io::path mergeFilename(const io::path &path, const io::path &filename, const io::path &extension = "")
{ {
io::path result(path); io::path result(path);
if ( !result.empty() ) if (!result.empty()) {
{
fschar_t last = result.lastChar(); fschar_t last = result.lastChar();
if ( last != _IRR_TEXT('/') && last != _IRR_TEXT('\\') ) if (last != _IRR_TEXT('/') && last != _IRR_TEXT('\\'))
result += _IRR_TEXT('/'); result += _IRR_TEXT('/');
} }
if ( !filename.empty() ) if (!filename.empty())
result += filename; result += filename;
if ( !extension.empty() ) if (!extension.empty()) {
{ if (!result.empty() && extension[0] != _IRR_TEXT('.'))
if ( !result.empty() && extension[0] != _IRR_TEXT('.') )
result += _IRR_TEXT('.'); result += _IRR_TEXT('.');
result += extension; result += extension;
} }
@ -191,13 +176,19 @@ static inline io::path mergeFilename(const io::path& path, const io::path& filen
return result; return result;
} }
//! some standard function ( to remove dependencies ) //! some standard function ( to remove dependencies )
inline bool isdigit(s32 c) { return c >= '0' && c <= '9'; } inline bool isdigit(s32 c)
inline bool isspace(s32 c) { return c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v'; } {
inline bool isupper(s32 c) { return c >= 'A' && c <= 'Z'; } return c >= '0' && c <= '9';
}
inline bool isspace(s32 c)
{
return c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v';
}
inline bool isupper(s32 c)
{
return c >= 'A' && c <= 'Z';
}
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr

354
include/dimension2d.h
View File

@ -11,212 +11,206 @@ namespace irr
{ {
namespace core namespace core
{ {
template <class T> template <class T>
class vector2d; class vector2d;
//! Specifies a 2 dimensional size. //! Specifies a 2 dimensional size.
template <class T> template <class T>
class dimension2d class dimension2d
{
public:
//! Default constructor for empty dimension
constexpr dimension2d() :
Width(0), Height(0) {}
//! Constructor with width and height
constexpr dimension2d(const T &width, const T &height) :
Width(width), Height(height) {}
dimension2d(const vector2d<T> &other); // Defined in vector2d.h
//! Use this constructor only where you are sure that the conversion is valid.
template <class U>
explicit constexpr dimension2d(const dimension2d<U> &other) :
Width((T)other.Width), Height((T)other.Height)
{ {
public: }
//! Default constructor for empty dimension
constexpr dimension2d() : Width(0), Height(0) {}
//! Constructor with width and height
constexpr dimension2d(const T& width, const T& height)
: Width(width), Height(height) {}
dimension2d(const vector2d<T>& other); // Defined in vector2d.h template <class U>
dimension2d<T> &operator=(const dimension2d<U> &other)
{
Width = (T)other.Width;
Height = (T)other.Height;
return *this;
}
//! Use this constructor only where you are sure that the conversion is valid. //! Equality operator
template <class U> bool operator==(const dimension2d<T> &other) const
explicit constexpr dimension2d(const dimension2d<U>& other) : {
Width((T)other.Width), Height((T)other.Height) { } return core::equals(Width, other.Width) &&
core::equals(Height, other.Height);
}
template <class U> //! Inequality operator
dimension2d<T>& operator=(const dimension2d<U>& other) bool operator!=(const dimension2d<T> &other) const
{ {
Width = (T) other.Width; return !(*this == other);
Height = (T) other.Height; }
return *this;
}
bool operator==(const vector2d<T> &other) const; // Defined in vector2d.h
//! Equality operator bool operator!=(const vector2d<T> &other) const
bool operator==(const dimension2d<T>& other) const {
{ return !(*this == other);
return core::equals(Width, other.Width) && }
core::equals(Height, other.Height);
}
//! Inequality operator //! Set to new values
bool operator!=(const dimension2d<T>& other) const dimension2d<T> &set(const T &width, const T &height)
{ {
return ! (*this == other); Width = width;
} Height = height;
return *this;
}
bool operator==(const vector2d<T>& other) const; // Defined in vector2d.h //! Divide width and height by scalar
dimension2d<T> &operator/=(const T &scale)
{
Width /= scale;
Height /= scale;
return *this;
}
bool operator!=(const vector2d<T>& other) const //! Divide width and height by scalar
{ dimension2d<T> operator/(const T &scale) const
return !(*this == other); {
} return dimension2d<T>(Width / scale, Height / scale);
}
//! Set to new values //! Multiply width and height by scalar
dimension2d<T>& set(const T& width, const T& height) dimension2d<T> &operator*=(const T &scale)
{ {
Width = width; Width *= scale;
Height = height; Height *= scale;
return *this; return *this;
} }
//! Divide width and height by scalar //! Multiply width and height by scalar
dimension2d<T>& operator/=(const T& scale) dimension2d<T> operator*(const T &scale) const
{ {
Width /= scale; return dimension2d<T>(Width * scale, Height * scale);
Height /= scale; }
return *this;
}
//! Divide width and height by scalar //! Add another dimension to this one.
dimension2d<T> operator/(const T& scale) const dimension2d<T> &operator+=(const dimension2d<T> &other)
{ {
return dimension2d<T>(Width/scale, Height/scale); Width += other.Width;
} Height += other.Height;
return *this;
}
//! Multiply width and height by scalar //! Add two dimensions
dimension2d<T>& operator*=(const T& scale) dimension2d<T> operator+(const dimension2d<T> &other) const
{ {
Width *= scale; return dimension2d<T>(Width + other.Width, Height + other.Height);
Height *= scale; }
return *this;
}
//! Multiply width and height by scalar //! Subtract a dimension from this one
dimension2d<T> operator*(const T& scale) const dimension2d<T> &operator-=(const dimension2d<T> &other)
{ {
return dimension2d<T>(Width*scale, Height*scale); Width -= other.Width;
} Height -= other.Height;
return *this;
}
//! Add another dimension to this one. //! Subtract one dimension from another
dimension2d<T>& operator+=(const dimension2d<T>& other) dimension2d<T> operator-(const dimension2d<T> &other) const
{ {
Width += other.Width; return dimension2d<T>(Width - other.Width, Height - other.Height);
Height += other.Height; }
return *this;
}
//! Add two dimensions //! Get area
dimension2d<T> operator+(const dimension2d<T>& other) const T getArea() const
{ {
return dimension2d<T>(Width+other.Width, Height+other.Height); return Width * Height;
} }
//! Subtract a dimension from this one //! Get the optimal size according to some properties
dimension2d<T>& operator-=(const dimension2d<T>& other) /** This is a function often used for texture dimension
{ calculations. The function returns the next larger or
Width -= other.Width; smaller dimension which is a power-of-two dimension
Height -= other.Height; (2^n,2^m) and/or square (Width=Height).
return *this; \param requirePowerOfTwo Forces the result to use only
} powers of two as values.
\param requireSquare Makes width==height in the result
\param larger Choose whether the result is larger or
smaller than the current dimension. If one dimension
need not be changed it is kept with any value of larger.
\param maxValue Maximum texturesize. if value > 0 size is
clamped to maxValue
\return The optimal dimension under the given
constraints. */
dimension2d<T> getOptimalSize(
bool requirePowerOfTwo = true,
bool requireSquare = false,
bool larger = true,
u32 maxValue = 0) const
{
u32 i = 1;
u32 j = 1;
if (requirePowerOfTwo) {
while (i < (u32)Width)
i <<= 1;
if (!larger && i != 1 && i != (u32)Width)
i >>= 1;
while (j < (u32)Height)
j <<= 1;
if (!larger && j != 1 && j != (u32)Height)
j >>= 1;
} else {
i = (u32)Width;
j = (u32)Height;
}
//! Subtract one dimension from another if (requireSquare) {
dimension2d<T> operator-(const dimension2d<T>& other) const if ((larger && (i > j)) || (!larger && (i < j)))
{ j = i;
return dimension2d<T>(Width-other.Width, Height-other.Height); else
} i = j;
}
//! Get area if (maxValue > 0 && i > maxValue)
T getArea() const i = maxValue;
{
return Width*Height;
}
//! Get the optimal size according to some properties if (maxValue > 0 && j > maxValue)
/** This is a function often used for texture dimension j = maxValue;
calculations. The function returns the next larger or
smaller dimension which is a power-of-two dimension
(2^n,2^m) and/or square (Width=Height).
\param requirePowerOfTwo Forces the result to use only
powers of two as values.
\param requireSquare Makes width==height in the result
\param larger Choose whether the result is larger or
smaller than the current dimension. If one dimension
need not be changed it is kept with any value of larger.
\param maxValue Maximum texturesize. if value > 0 size is
clamped to maxValue
\return The optimal dimension under the given
constraints. */
dimension2d<T> getOptimalSize(
bool requirePowerOfTwo=true,
bool requireSquare=false,
bool larger=true,
u32 maxValue = 0) const
{
u32 i=1;
u32 j=1;
if (requirePowerOfTwo)
{
while (i<(u32)Width)
i<<=1;
if (!larger && i!=1 && i!=(u32)Width)
i>>=1;
while (j<(u32)Height)
j<<=1;
if (!larger && j!=1 && j!=(u32)Height)
j>>=1;
}
else
{
i=(u32)Width;
j=(u32)Height;
}
if (requireSquare) return dimension2d<T>((T)i, (T)j);
{ }
if ((larger && (i>j)) || (!larger && (i<j)))
j=i;
else
i=j;
}
if ( maxValue > 0 && i > maxValue) //! Get the interpolated dimension
i = maxValue; /** \param other Other dimension to interpolate with.
\param d Value between 0.0f and 1.0f. d=0 returns other, d=1 returns this, values between interpolate.
\return Interpolated dimension. */
dimension2d<T> getInterpolated(const dimension2d<T> &other, f32 d) const
{
f32 inv = (1.0f - d);
return dimension2d<T>((T)(other.Width * inv + Width * d), (T)(other.Height * inv + Height * d));
}
if ( maxValue > 0 && j > maxValue) //! Width of the dimension.
j = maxValue; T Width;
//! Height of the dimension.
T Height;
};
return dimension2d<T>((T)i,(T)j); //! Typedef for an f32 dimension.
} typedef dimension2d<f32> dimension2df;
//! Typedef for an unsigned integer dimension.
//! Get the interpolated dimension typedef dimension2d<u32> dimension2du;
/** \param other Other dimension to interpolate with.
\param d Value between 0.0f and 1.0f. d=0 returns other, d=1 returns this, values between interpolate.
\return Interpolated dimension. */
dimension2d<T> getInterpolated(const dimension2d<T>& other, f32 d) const
{
f32 inv = (1.0f - d);
return dimension2d<T>( (T)(other.Width*inv + Width*d), (T)(other.Height*inv + Height*d));
}
//! Width of the dimension.
T Width;
//! Height of the dimension.
T Height;
};
//! Typedef for an f32 dimension.
typedef dimension2d<f32> dimension2df;
//! Typedef for an unsigned integer dimension.
typedef dimension2d<u32> dimension2du;
//! Typedef for an integer dimension.
/** There are few cases where negative dimensions make sense. Please consider using
dimension2du instead. */
typedef dimension2d<s32> dimension2di;
//! Typedef for an integer dimension.
/** There are few cases where negative dimensions make sense. Please consider using
dimension2du instead. */
typedef dimension2d<s32> dimension2di;
} // end namespace core } // end namespace core
} // end namespace irr } // end namespace irr

243
include/fast_atof.h
View File

@ -15,51 +15,47 @@ namespace core
#define IRR_ATOF_TABLE_SIZE 17 #define IRR_ATOF_TABLE_SIZE 17
// we write [IRR_ATOF_TABLE_SIZE] here instead of [] to work around a swig bug // we write [IRR_ATOF_TABLE_SIZE] here instead of [] to work around a swig bug
const float fast_atof_table[17] = { const float fast_atof_table[17] = {
0.f, 0.f,
0.1f, 0.1f,
0.01f, 0.01f,
0.001f, 0.001f,
0.0001f, 0.0001f,
0.00001f, 0.00001f,
0.000001f, 0.000001f,
0.0000001f, 0.0000001f,
0.00000001f, 0.00000001f,
0.000000001f, 0.000000001f,
0.0000000001f, 0.0000000001f,
0.00000000001f, 0.00000000001f,
0.000000000001f, 0.000000000001f,
0.0000000000001f, 0.0000000000001f,
0.00000000000001f, 0.00000000000001f,
0.000000000000001f, 0.000000000000001f,
0.0000000000000001f 0.0000000000000001f};
};
//! Convert a simple string of base 10 digits into an unsigned 32 bit integer. //! Convert a simple string of base 10 digits into an unsigned 32 bit integer.
/** \param[in] in: The string of digits to convert. No leading chars are /** \param[in] in: The string of digits to convert. No leading chars are
allowed, only digits 0 to 9. Parsing stops at the first non-digit. allowed, only digits 0 to 9. Parsing stops at the first non-digit.
\param[out] out: (optional) If provided, it will be set to point at the \param[out] out: (optional) If provided, it will be set to point at the
first character not used in the calculation. first character not used in the calculation.
\return The unsigned integer value of the digits. If the string specifies \return The unsigned integer value of the digits. If the string specifies
too many digits to encode in an u32 then INT_MAX will be returned. too many digits to encode in an u32 then INT_MAX will be returned.
*/ */
inline u32 strtoul10(const char* in, const char** out=0) inline u32 strtoul10(const char *in, const char **out = 0)
{ {
if (!in) if (!in) {
{
if (out) if (out)
*out = in; *out = in;
return 0; return 0;
} }
bool overflow=false; bool overflow = false;
u32 unsignedValue = 0; u32 unsignedValue = 0;
while ( ( *in >= '0') && ( *in <= '9' )) while ((*in >= '0') && (*in <= '9')) {
{ const u32 tmp = (unsignedValue * 10) + (*in - '0');
const u32 tmp = ( unsignedValue * 10 ) + ( *in - '0' ); if (tmp < unsignedValue) {
if (tmp<unsignedValue) unsignedValue = (u32)0xffffffff;
{ overflow = true;
unsignedValue=(u32)0xffffffff;
overflow=true;
} }
if (!overflow) if (!overflow)
unsignedValue = tmp; unsignedValue = tmp;
@ -74,18 +70,17 @@ inline u32 strtoul10(const char* in, const char** out=0)
//! Convert a simple string of base 10 digits into a signed 32 bit integer. //! Convert a simple string of base 10 digits into a signed 32 bit integer.
/** \param[in] in: The string of digits to convert. Only a leading - or + /** \param[in] in: The string of digits to convert. Only a leading - or +
followed by digits 0 to 9 will be considered. Parsing stops at the first followed by digits 0 to 9 will be considered. Parsing stops at the first
non-digit. non-digit.
\param[out] out: (optional) If provided, it will be set to point at the \param[out] out: (optional) If provided, it will be set to point at the
first character not used in the calculation. first character not used in the calculation.
\return The signed integer value of the digits. If the string specifies \return The signed integer value of the digits. If the string specifies
too many digits to encode in an s32 then +INT_MAX or -INT_MAX will be too many digits to encode in an s32 then +INT_MAX or -INT_MAX will be
returned. returned.
*/ */
inline s32 strtol10(const char* in, const char** out=0) inline s32 strtol10(const char *in, const char **out = 0)
{ {
if (!in) if (!in) {
{
if (out) if (out)
*out = in; *out = in;
return 0; return 0;
@ -95,16 +90,13 @@ inline s32 strtol10(const char* in, const char** out=0)
if (negative || ('+' == *in)) if (negative || ('+' == *in))
++in; ++in;
const u32 unsignedValue = strtoul10(in,out); const u32 unsignedValue = strtoul10(in, out);
if (unsignedValue > (u32)INT_MAX) if (unsignedValue > (u32)INT_MAX) {
{
if (negative) if (negative)
return (s32)INT_MIN; return (s32)INT_MIN;
else else
return (s32)INT_MAX; return (s32)INT_MAX;
} } else {
else
{
if (negative) if (negative)
return -((s32)unsignedValue); return -((s32)unsignedValue);
else else
@ -114,9 +106,9 @@ inline s32 strtol10(const char* in, const char** out=0)
//! Convert a hex-encoded character to an unsigned integer. //! Convert a hex-encoded character to an unsigned integer.
/** \param[in] in The digit to convert. Only digits 0 to 9 and chars A-F,a-f /** \param[in] in The digit to convert. Only digits 0 to 9 and chars A-F,a-f
will be considered. will be considered.
\return The unsigned integer value of the digit. 0xffffffff if the input is \return The unsigned integer value of the digit. 0xffffffff if the input is
not hex not hex
*/ */
inline u32 ctoul16(char in) inline u32 ctoul16(char in)
{ {
@ -132,26 +124,24 @@ inline u32 ctoul16(char in)
//! Convert a simple string of base 16 digits into an unsigned 32 bit integer. //! Convert a simple string of base 16 digits into an unsigned 32 bit integer.
/** \param[in] in: The string of digits to convert. No leading chars are /** \param[in] in: The string of digits to convert. No leading chars are
allowed, only digits 0 to 9 and chars A-F,a-f are allowed. Parsing stops allowed, only digits 0 to 9 and chars A-F,a-f are allowed. Parsing stops
at the first illegal char. at the first illegal char.
\param[out] out: (optional) If provided, it will be set to point at the \param[out] out: (optional) If provided, it will be set to point at the
first character not used in the calculation. first character not used in the calculation.
\return The unsigned integer value of the digits. If the string specifies \return The unsigned integer value of the digits. If the string specifies
too many digits to encode in an u32 then INT_MAX will be returned. too many digits to encode in an u32 then INT_MAX will be returned.
*/ */
inline u32 strtoul16(const char* in, const char** out=0) inline u32 strtoul16(const char *in, const char **out = 0)
{ {
if (!in) if (!in) {
{
if (out) if (out)
*out = in; *out = in;
return 0; return 0;
} }
bool overflow=false; bool overflow = false;
u32 unsignedValue = 0; u32 unsignedValue = 0;
while (true) while (true) {
{
u32 tmp = 0; u32 tmp = 0;
if ((*in >= '0') && (*in <= '9')) if ((*in >= '0') && (*in <= '9'))
tmp = (unsignedValue << 4u) + (*in - '0'); tmp = (unsignedValue << 4u) + (*in - '0');
@ -161,10 +151,9 @@ inline u32 strtoul16(const char* in, const char** out=0)
tmp = (unsignedValue << 4u) + (*in - 'a') + 10; tmp = (unsignedValue << 4u) + (*in - 'a') + 10;
else else
break; break;
if (tmp<unsignedValue) if (tmp < unsignedValue) {
{ unsignedValue = (u32)INT_MAX;
unsignedValue=(u32)INT_MAX; overflow = true;
overflow=true;
} }
if (!overflow) if (!overflow)
unsignedValue = tmp; unsignedValue = tmp;
@ -179,35 +168,32 @@ inline u32 strtoul16(const char* in, const char** out=0)
//! Convert a simple string of base 8 digits into an unsigned 32 bit integer. //! Convert a simple string of base 8 digits into an unsigned 32 bit integer.
/** \param[in] in The string of digits to convert. No leading chars are /** \param[in] in The string of digits to convert. No leading chars are
allowed, only digits 0 to 7 are allowed. Parsing stops at the first illegal allowed, only digits 0 to 7 are allowed. Parsing stops at the first illegal
char. char.
\param[out] out (optional) If provided, it will be set to point at the \param[out] out (optional) If provided, it will be set to point at the
first character not used in the calculation. first character not used in the calculation.
\return The unsigned integer value of the digits. If the string specifies \return The unsigned integer value of the digits. If the string specifies
too many digits to encode in an u32 then INT_MAX will be returned. too many digits to encode in an u32 then INT_MAX will be returned.
*/ */
inline u32 strtoul8(const char* in, const char** out=0) inline u32 strtoul8(const char *in, const char **out = 0)
{ {
if (!in) if (!in) {
{
if (out) if (out)
*out = in; *out = in;
return 0; return 0;
} }
bool overflow=false; bool overflow = false;
u32 unsignedValue = 0; u32 unsignedValue = 0;
while (true) while (true) {
{
u32 tmp = 0; u32 tmp = 0;
if ((*in >= '0') && (*in <= '7')) if ((*in >= '0') && (*in <= '7'))
tmp = (unsignedValue << 3u) + (*in - '0'); tmp = (unsignedValue << 3u) + (*in - '0');
else else
break; break;
if (tmp<unsignedValue) if (tmp < unsignedValue) {
{ unsignedValue = (u32)INT_MAX;
unsignedValue=(u32)INT_MAX; overflow = true;
overflow=true;
} }
if (!overflow) if (!overflow)
unsignedValue = tmp; unsignedValue = tmp;
@ -222,39 +208,37 @@ inline u32 strtoul8(const char* in, const char** out=0)
//! Convert a C-style prefixed string (hex, oct, integer) into an unsigned 32 bit integer. //! Convert a C-style prefixed string (hex, oct, integer) into an unsigned 32 bit integer.
/** \param[in] in The string of digits to convert. If string starts with 0x the /** \param[in] in The string of digits to convert. If string starts with 0x the
hex parser is used, if only leading 0 is used, oct parser is used. In all hex parser is used, if only leading 0 is used, oct parser is used. In all
other cases, the usual unsigned parser is used. other cases, the usual unsigned parser is used.
\param[out] out (optional) If provided, it will be set to point at the \param[out] out (optional) If provided, it will be set to point at the
first character not used in the calculation. first character not used in the calculation.
\return The unsigned integer value of the digits. If the string specifies \return The unsigned integer value of the digits. If the string specifies
too many digits to encode in an u32 then INT_MAX will be returned. too many digits to encode in an u32 then INT_MAX will be returned.
*/ */
inline u32 strtoul_prefix(const char* in, const char** out=0) inline u32 strtoul_prefix(const char *in, const char **out = 0)
{ {
if (!in) if (!in) {
{
if (out) if (out)
*out = in; *out = in;
return 0; return 0;
} }
if ('0'==in[0]) if ('0' == in[0])
return ('x'==in[1] ? strtoul16(in+2,out) : strtoul8(in+1,out)); return ('x' == in[1] ? strtoul16(in + 2, out) : strtoul8(in + 1, out));
return strtoul10(in,out); return strtoul10(in, out);
} }
//! Converts a sequence of digits into a whole positive floating point value. //! Converts a sequence of digits into a whole positive floating point value.
/** Only digits 0 to 9 are parsed. Parsing stops at any other character, /** Only digits 0 to 9 are parsed. Parsing stops at any other character,
including sign characters or a decimal point. including sign characters or a decimal point.
\param in: the sequence of digits to convert. \param in: the sequence of digits to convert.
\param out: (optional) will be set to point at the first non-converted \param out: (optional) will be set to point at the first non-converted
character. character.
\return The whole positive floating point representation of the digit \return The whole positive floating point representation of the digit
sequence. sequence.
*/ */
inline f32 strtof10(const char* in, const char** out = 0) inline f32 strtof10(const char *in, const char **out = 0)
{ {
if (!in) if (!in) {
{
if (out) if (out)
*out = in; *out = in;
return 0.f; return 0.f;
@ -265,8 +249,7 @@ inline f32 strtof10(const char* in, const char** out = 0)
// Use integer arithmetic for as long as possible, for speed // Use integer arithmetic for as long as possible, for speed
// and precision. // and precision.
while ( ( *in >= '0') && ( *in <= '9' ) ) while ((*in >= '0') && (*in <= '9')) {
{
// If it looks like we're going to overflow, bail out // If it looks like we're going to overflow, bail out
// now and start using floating point. // now and start using floating point.
if (intValue >= MAX_SAFE_U32_VALUE) if (intValue >= MAX_SAFE_U32_VALUE)
@ -280,8 +263,7 @@ inline f32 strtof10(const char* in, const char** out = 0)
// If there are any digits left to parse, then we need to use // If there are any digits left to parse, then we need to use
// floating point arithmetic from here. // floating point arithmetic from here.
while ( ( *in >= '0') && ( *in <= '9' ) ) while ((*in >= '0') && (*in <= '9')) {
{
floatValue = (floatValue * 10.f) + (f32)(*in - '0'); floatValue = (floatValue * 10.f) + (f32)(*in - '0');
++in; ++in;
if (floatValue > FLT_MAX) // Just give up. if (floatValue > FLT_MAX) // Just give up.
@ -296,13 +278,13 @@ inline f32 strtof10(const char* in, const char** out = 0)
//! Provides a fast function for converting a string into a float. //! Provides a fast function for converting a string into a float.
/** This is not guaranteed to be as accurate as atof(), but is /** This is not guaranteed to be as accurate as atof(), but is
approximately 6 to 8 times as fast. approximately 6 to 8 times as fast.
\param[in] in The string to convert. \param[in] in The string to convert.
\param[out] result The resultant float will be written here. \param[out] result The resultant float will be written here.
\return Pointer to the first character in the string that wasn't used \return Pointer to the first character in the string that wasn't used
to create the float value. to create the float value.
*/ */
inline const char* fast_atof_move(const char* in, f32& result) inline const char *fast_atof_move(const char *in, f32 &result)
{ {
// Please run the regression test when making any modifications to this function. // Please run the regression test when making any modifications to this function.
@ -311,29 +293,24 @@ inline const char* fast_atof_move(const char* in, f32& result)
return 0; return 0;
const bool negative = ('-' == *in); const bool negative = ('-' == *in);
if (negative || ('+'==*in)) if (negative || ('+' == *in))
++in; ++in;
f32 value = strtof10(in, &in); f32 value = strtof10(in, &in);
if ( *in == '.' ) if (*in == '.') {
{ const char *afterDecimal = ++in;
const char* afterDecimal = ++in;
const f32 decimal = strtof10(in, &afterDecimal); const f32 decimal = strtof10(in, &afterDecimal);
const size_t numDecimals = afterDecimal - in; const size_t numDecimals = afterDecimal - in;
if (numDecimals < IRR_ATOF_TABLE_SIZE) if (numDecimals < IRR_ATOF_TABLE_SIZE) {
{
value += decimal * fast_atof_table[numDecimals]; value += decimal * fast_atof_table[numDecimals];
} } else {
else
{
value += decimal * (f32)pow(10.f, -(float)numDecimals); value += decimal * (f32)pow(10.f, -(float)numDecimals);
} }
in = afterDecimal; in = afterDecimal;
} }
if ('e' == *in || 'E' == *in) if ('e' == *in || 'E' == *in) {
{
++in; ++in;
// Assume that the exponent is a whole number. // Assume that the exponent is a whole number.
// strtol10() will deal with both + and - signs, // strtol10() will deal with both + and - signs,
@ -342,21 +319,21 @@ inline const char* fast_atof_move(const char* in, f32& result)
value *= (f32)pow(10.f, (f32)strtol10(in, &in)); value *= (f32)pow(10.f, (f32)strtol10(in, &in));
} }
result = negative?-value:value; result = negative ? -value : value;
return in; return in;
} }
//! Convert a string to a floating point number //! Convert a string to a floating point number
/** \param floatAsString The string to convert. /** \param floatAsString The string to convert.
\param out Optional pointer to the first character in the string that \param out Optional pointer to the first character in the string that
wasn't used to create the float value. wasn't used to create the float value.
\result Float value parsed from the input string \result Float value parsed from the input string
*/ */
inline float fast_atof(const char* floatAsString, const char** out=0) inline float fast_atof(const char *floatAsString, const char **out = 0)
{ {
float ret; float ret;
if (out) if (out)
*out=fast_atof_move(floatAsString, ret); *out = fast_atof_move(floatAsString, ret);
else else
fast_atof_move(floatAsString, ret); fast_atof_move(floatAsString, ret);
return ret; return ret;

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