mirror of
https://github.com/minetest/irrlicht.git
synced 2025-02-20 13:00:18 +01:00
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:
parent
9814510b1b
commit
f5c6d3e945
@ -28,14 +28,14 @@ static video::E_DRIVER_TYPE chooseDriver(core::stringc arg_)
|
||||
|
||||
static inline void check(bool ok, const char *msg)
|
||||
{
|
||||
if (!ok)
|
||||
{
|
||||
if (!ok) {
|
||||
test_fail++;
|
||||
device->getLogger()->log((core::stringc("FAILED TEST: ") + msg).c_str(), ELL_ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
void run_unit_tests() {
|
||||
void run_unit_tests()
|
||||
{
|
||||
std::cout << "Running unit tests:" << std::endl;
|
||||
try {
|
||||
test_irr_array();
|
||||
@ -93,13 +93,11 @@ int main(int argc, char *argv[])
|
||||
check(mesh, "mesh loading");
|
||||
if (mesh_file)
|
||||
mesh_file->drop();
|
||||
if (mesh)
|
||||
{
|
||||
if (mesh) {
|
||||
video::ITexture *tex = driver->getTexture(mediaPath + "cooltexture.png");
|
||||
check(tex, "texture loading");
|
||||
scene::IAnimatedMeshSceneNode *node = smgr->addAnimatedMeshSceneNode(mesh);
|
||||
if (node)
|
||||
{
|
||||
if (node) {
|
||||
node->forEachMaterial([tex](video::SMaterial &mat) {
|
||||
mat.Lighting = false;
|
||||
mat.setTexture(0, tex);
|
||||
@ -115,10 +113,8 @@ int main(int argc, char *argv[])
|
||||
SEvent event;
|
||||
device->getTimer()->start();
|
||||
|
||||
while (device->run())
|
||||
{
|
||||
if (device->getTimer()->getTime() >= 1000)
|
||||
{
|
||||
while (device->run()) {
|
||||
if (device->getTimer()->getTime() >= 1000) {
|
||||
device->getTimer()->setTime(0);
|
||||
++n;
|
||||
if (n == 1) // Tooltip display
|
||||
@ -129,8 +125,7 @@ int main(int argc, char *argv[])
|
||||
event.MouseInput.X = button->getAbsolutePosition().getCenter().X;
|
||||
event.MouseInput.Y = button->getAbsolutePosition().getCenter().Y;
|
||||
device->postEventFromUser(event);
|
||||
}
|
||||
else if (n == 2) // Text input focus
|
||||
} else if (n == 2) // Text input focus
|
||||
guienv->setFocus(editbox);
|
||||
else if (n == 3) // Keypress for Text input
|
||||
{
|
||||
@ -142,8 +137,7 @@ int main(int argc, char *argv[])
|
||||
device->postEventFromUser(event);
|
||||
event.KeyInput.PressedDown = false;
|
||||
device->postEventFromUser(event);
|
||||
}
|
||||
else
|
||||
} else
|
||||
device->closeDevice();
|
||||
}
|
||||
|
||||
|
@ -4,7 +4,8 @@
|
||||
using namespace irr;
|
||||
using core::array;
|
||||
|
||||
static void test_basics() {
|
||||
static void test_basics()
|
||||
{
|
||||
array<int> v;
|
||||
v.push_back(1); // 1
|
||||
v.push_front(2); // 2, 1
|
||||
@ -57,7 +58,8 @@ static void test_basics() {
|
||||
UASSERTEQ(v.size(), 2);
|
||||
}
|
||||
|
||||
static void test_linear_searches() {
|
||||
static void test_linear_searches()
|
||||
{
|
||||
// Populate the array with 0, 1, 2, ..., 100, 100, 99, 98, 97, ..., 0
|
||||
array<int> arr;
|
||||
for (int i = 0; i <= 100; i++)
|
||||
@ -75,7 +77,8 @@ static void test_linear_searches() {
|
||||
}
|
||||
}
|
||||
|
||||
static void test_binary_searches() {
|
||||
static void test_binary_searches()
|
||||
{
|
||||
const auto &values = {3, 5, 1, 2, 5, 10, 19, 9, 7, 1, 2, 5, 8, 15};
|
||||
array<int> arr;
|
||||
for (int value : values) {
|
||||
|
@ -3,11 +3,13 @@
|
||||
#include <exception>
|
||||
#include <iostream>
|
||||
|
||||
class TestFailedException : public std::exception {
|
||||
class TestFailedException : public std::exception
|
||||
{
|
||||
};
|
||||
|
||||
// Asserts the comparison specified by CMP is true, or fails the current unit test
|
||||
#define UASSERTCMP(CMP, actual, expected) do { \
|
||||
#define UASSERTCMP(CMP, actual, expected) \
|
||||
do { \
|
||||
const auto &a = (actual); \
|
||||
const auto &e = (expected); \
|
||||
if (!CMP(a, e)) { \
|
||||
@ -15,7 +17,8 @@ class TestFailedException : public std::exception {
|
||||
<< "Test assertion failed: " << #actual << " " << #CMP << " " \
|
||||
<< #expected << std::endl \
|
||||
<< " at " << __FILE__ << ":" << __LINE__ << std::endl \
|
||||
<< " actual: " << a << std::endl << " expected: " \
|
||||
<< " actual: " << a << std::endl \
|
||||
<< " expected: " \
|
||||
<< e << std::endl; \
|
||||
throw TestFailedException(); \
|
||||
} \
|
||||
|
@ -17,18 +17,14 @@ namespace scene
|
||||
{
|
||||
public:
|
||||
//! Default constructor for empty meshbuffer
|
||||
CMeshBuffer()
|
||||
: ChangedID_Vertex(1), ChangedID_Index(1)
|
||||
, MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER)
|
||||
, HWBuffer(NULL)
|
||||
, PrimitiveType(EPT_TRIANGLES)
|
||||
CMeshBuffer() :
|
||||
ChangedID_Vertex(1), ChangedID_Index(1), MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER), HWBuffer(NULL), PrimitiveType(EPT_TRIANGLES)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
setDebugName("CMeshBuffer");
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
//! Get material of this meshbuffer
|
||||
/** \return Material of this buffer */
|
||||
const video::SMaterial &getMaterial() const override
|
||||
@ -36,7 +32,6 @@ namespace scene
|
||||
return Material;
|
||||
}
|
||||
|
||||
|
||||
//! Get material of this meshbuffer
|
||||
/** \return Material of this buffer */
|
||||
video::SMaterial &getMaterial() override
|
||||
@ -44,7 +39,6 @@ namespace scene
|
||||
return Material;
|
||||
}
|
||||
|
||||
|
||||
//! Get pointer to vertices
|
||||
/** \return Pointer to vertices. */
|
||||
const void *getVertices() const override
|
||||
@ -52,7 +46,6 @@ namespace scene
|
||||
return Vertices.const_pointer();
|
||||
}
|
||||
|
||||
|
||||
//! Get pointer to vertices
|
||||
/** \return Pointer to vertices. */
|
||||
void *getVertices() override
|
||||
@ -60,7 +53,6 @@ namespace scene
|
||||
return Vertices.pointer();
|
||||
}
|
||||
|
||||
|
||||
//! Get number of vertices
|
||||
/** \return Number of vertices. */
|
||||
u32 getVertexCount() const override
|
||||
@ -82,7 +74,6 @@ namespace scene
|
||||
return Indices.const_pointer();
|
||||
}
|
||||
|
||||
|
||||
//! Get pointer to indices
|
||||
/** \return Pointer to indices. */
|
||||
u16 *getIndices() override
|
||||
@ -90,7 +81,6 @@ namespace scene
|
||||
return Indices.pointer();
|
||||
}
|
||||
|
||||
|
||||
//! Get number of indices
|
||||
/** \return Number of indices. */
|
||||
u32 getIndexCount() const override
|
||||
@ -98,7 +88,6 @@ namespace scene
|
||||
return Indices.size();
|
||||
}
|
||||
|
||||
|
||||
//! Get the axis aligned bounding box
|
||||
/** \return Axis aligned bounding box of this buffer. */
|
||||
const core::aabbox3d<f32> &getBoundingBox() const override
|
||||
@ -106,7 +95,6 @@ namespace scene
|
||||
return BoundingBox;
|
||||
}
|
||||
|
||||
|
||||
//! Set the axis aligned bounding box
|
||||
/** \param box New axis aligned bounding box for this buffer. */
|
||||
//! set user axis aligned bounding box
|
||||
@ -115,24 +103,19 @@ namespace scene
|
||||
BoundingBox = box;
|
||||
}
|
||||
|
||||
|
||||
//! Recalculate the bounding box.
|
||||
/** should be called if the mesh changed. */
|
||||
void recalculateBoundingBox() override
|
||||
{
|
||||
if (!Vertices.empty())
|
||||
{
|
||||
if (!Vertices.empty()) {
|
||||
BoundingBox.reset(Vertices[0].Pos);
|
||||
const irr::u32 vsize = Vertices.size();
|
||||
for (u32 i = 1; i < vsize; ++i)
|
||||
BoundingBox.addInternalPoint(Vertices[i].Pos);
|
||||
}
|
||||
else
|
||||
} 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
|
||||
@ -176,7 +159,6 @@ namespace scene
|
||||
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
|
||||
@ -191,20 +173,17 @@ namespace scene
|
||||
u32 i;
|
||||
|
||||
Vertices.reallocate(vertexCount + numVertices);
|
||||
for (i=0; i<numVertices; ++i)
|
||||
{
|
||||
for (i = 0; i < numVertices; ++i) {
|
||||
Vertices.push_back(static_cast<const T *>(vertices)[i]);
|
||||
BoundingBox.addInternalPoint(static_cast<const T *>(vertices)[i].Pos);
|
||||
}
|
||||
|
||||
Indices.reallocate(getIndexCount() + numIndices);
|
||||
for (i=0; i<numIndices; ++i)
|
||||
{
|
||||
for (i = 0; i < numIndices; ++i) {
|
||||
Indices.push_back(indices[i] + vertexCount);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! get the current hardware mapping hint
|
||||
E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const override
|
||||
{
|
||||
@ -255,15 +234,16 @@ namespace scene
|
||||
/** This shouldn't be used for anything outside the VideoDriver. */
|
||||
u32 getChangedID_Index() const override { return ChangedID_Index; }
|
||||
|
||||
void setHWBuffer(void *ptr) const override {
|
||||
void setHWBuffer(void *ptr) const override
|
||||
{
|
||||
HWBuffer = ptr;
|
||||
}
|
||||
|
||||
void *getHWBuffer() const override {
|
||||
void *getHWBuffer() const override
|
||||
{
|
||||
return HWBuffer;
|
||||
}
|
||||
|
||||
|
||||
u32 ChangedID_Vertex;
|
||||
u32 ChangedID_Index;
|
||||
|
||||
|
@ -29,8 +29,7 @@ namespace scene
|
||||
"frustum_box", // camera frustum against node box
|
||||
"frustum_sphere", // camera frustum against node sphere
|
||||
"occ_query", // occlusion query
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -37,6 +37,5 @@ namespace scene
|
||||
EDS_FULL = 0xffffffff
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -29,8 +29,7 @@ const c8* const GUIAlignmentNames[] =
|
||||
"lowerRight",
|
||||
"center",
|
||||
"scale",
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
} // namespace gui
|
||||
} // namespace irr
|
||||
|
@ -127,8 +127,7 @@ const c8* const GUIElementTypeNames[] =
|
||||
"element",
|
||||
"root",
|
||||
"profiler",
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -65,8 +65,7 @@ namespace video
|
||||
"trans_alphach_ref",
|
||||
"trans_vertex_alpha",
|
||||
"onetexture_blend",
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
constexpr u32 numBuiltInMaterials =
|
||||
sizeof(sBuiltInMaterialTypeNames) / sizeof(char *) - 1;
|
||||
|
@ -45,7 +45,5 @@ namespace scene
|
||||
ESNT_ANY = MAKE_IRR_ID('a', 'n', 'y', '_')
|
||||
};
|
||||
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -81,6 +81,5 @@ const c8* const GEOMETRY_SHADER_TYPE_NAMES[] = {
|
||||
"gs_4_0",
|
||||
0};
|
||||
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
@ -28,8 +28,7 @@ const char* const sBuiltInVertexAttributeNames[] =
|
||||
"inTexCoord1",
|
||||
"inVertexTangent",
|
||||
"inVertexBinormal",
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
@ -19,7 +19,6 @@ namespace scene
|
||||
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,
|
||||
|
@ -24,7 +24,6 @@ namespace scene
|
||||
EJUOR_CONTROL
|
||||
};
|
||||
|
||||
|
||||
class IAnimatedMeshSceneNode;
|
||||
|
||||
//! Callback interface for catching events of ended animations.
|
||||
@ -35,7 +34,6 @@ namespace scene
|
||||
class IAnimationEndCallBack : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Will be called when the animation playback has ended.
|
||||
/** See IAnimatedMeshSceneNode::setAnimationEndCallback for
|
||||
more information.
|
||||
@ -47,13 +45,12 @@ namespace scene
|
||||
class IAnimatedMeshSceneNode : public ISceneNode
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor
|
||||
IAnimatedMeshSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id,
|
||||
const core::vector3df &position = core::vector3df(0, 0, 0),
|
||||
const core::vector3df &rotation = core::vector3df(0, 0, 0),
|
||||
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f))
|
||||
: ISceneNode(parent, mgr, id, position, rotation, scale) {}
|
||||
const core::vector3df &scale = core::vector3df(1.0f, 1.0f, 1.0f)) :
|
||||
ISceneNode(parent, mgr, id, position, rotation, scale) {}
|
||||
|
||||
//! Destructor
|
||||
virtual ~IAnimatedMeshSceneNode() {}
|
||||
@ -166,7 +163,6 @@ namespace scene
|
||||
\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
|
||||
|
@ -23,7 +23,6 @@ namespace io
|
||||
class IAttributes : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Returns amount of attributes in this collection of attributes.
|
||||
virtual u32 getAttributeCount() const = 0;
|
||||
|
||||
@ -48,7 +47,6 @@ public:
|
||||
//! Removes all attributes
|
||||
virtual void clear() = 0;
|
||||
|
||||
|
||||
/*
|
||||
|
||||
Integer Attribute
|
||||
@ -99,7 +97,6 @@ public:
|
||||
//! Sets an attribute as float value
|
||||
virtual void setAttribute(s32 index, f32 value) = 0;
|
||||
|
||||
|
||||
/*
|
||||
Bool Attribute
|
||||
*/
|
||||
@ -122,7 +119,6 @@ public:
|
||||
|
||||
//! Sets an attribute as boolean value
|
||||
virtual void setAttribute(s32 index, bool value) = 0;
|
||||
|
||||
};
|
||||
|
||||
} // end namespace io
|
||||
|
@ -21,11 +21,10 @@ lensflares, particles and things like that.
|
||||
class IBillboardSceneNode : public ISceneNode
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor
|
||||
IBillboardSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id,
|
||||
const core::vector3df& position = core::vector3df(0,0,0))
|
||||
: ISceneNode(parent, mgr, id, position) {}
|
||||
const core::vector3df &position = core::vector3df(0, 0, 0)) :
|
||||
ISceneNode(parent, mgr, id, position) {}
|
||||
|
||||
//! Sets the size of the billboard, making it rectangular.
|
||||
virtual void setSize(const core::dimension2d<f32> &size) = 0;
|
||||
|
@ -48,13 +48,11 @@ namespace scene
|
||||
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) {}
|
||||
|
||||
@ -95,6 +93,5 @@ namespace scene
|
||||
s32 rotationHint;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -22,13 +22,13 @@ namespace scene
|
||||
class ICameraSceneNode : public ISceneNode, public IEventReceiver
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor
|
||||
ICameraSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id,
|
||||
const core::vector3df &position = core::vector3df(0, 0, 0),
|
||||
const core::vector3df &rotation = core::vector3df(0, 0, 0),
|
||||
const core::vector3df& scale = core::vector3df(1.0f,1.0f,1.0f))
|
||||
: ISceneNode(parent, mgr, id, position, rotation, scale), IsOrthogonal(false) {}
|
||||
const core::vector3df &scale = core::vector3df(1.0f, 1.0f, 1.0f)) :
|
||||
ISceneNode(parent, mgr, id, position, rotation, scale),
|
||||
IsOrthogonal(false) {}
|
||||
|
||||
//! Sets the projection matrix of the camera.
|
||||
/** The core::matrix4 class has some methods to build a
|
||||
@ -172,7 +172,6 @@ namespace scene
|
||||
virtual bool getTargetAndRotationBinding(void) const = 0;
|
||||
|
||||
protected:
|
||||
|
||||
void cloneMembers(const ICameraSceneNode *toCopyFrom)
|
||||
{
|
||||
IsOrthogonal = toCopyFrom->IsOrthogonal;
|
||||
|
@ -57,5 +57,3 @@ namespace video
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
||||
|
||||
|
@ -56,19 +56,18 @@ namespace gui
|
||||
"sizens",
|
||||
"sizewe",
|
||||
"sizeup",
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
//! structure used to set sprites as cursors.
|
||||
struct SCursorSprite
|
||||
{
|
||||
SCursorSprite()
|
||||
: SpriteBank(0), SpriteId(-1)
|
||||
SCursorSprite() :
|
||||
SpriteBank(0), SpriteId(-1)
|
||||
{
|
||||
}
|
||||
|
||||
SCursorSprite( gui::IGUISpriteBank * spriteBank, s32 spriteId, const core::position2d<s32> &hotspot=(core::position2d<s32>(0,0)) )
|
||||
: SpriteBank(spriteBank), SpriteId(spriteId), HotSpot(hotspot)
|
||||
SCursorSprite(gui::IGUISpriteBank *spriteBank, s32 spriteId, const core::position2d<s32> &hotspot = (core::position2d<s32>(0, 0))) :
|
||||
SpriteBank(spriteBank), SpriteId(spriteId), HotSpot(hotspot)
|
||||
{
|
||||
}
|
||||
|
||||
@ -96,7 +95,6 @@ namespace gui
|
||||
class ICursorControl : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Changes the visible state of the mouse cursor.
|
||||
/** \param visible: The new visible state. If true, the cursor will be visible,
|
||||
if false, it will be invisible. */
|
||||
@ -193,6 +191,5 @@ namespace gui
|
||||
virtual ECURSOR_PLATFORM_BEHAVIOR getPlatformBehavior() const { return ECPB_NONE; }
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -22,10 +22,9 @@ joint scene nodes when playing skeletal animations.
|
||||
class IDummyTransformationSceneNode : public ISceneNode
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor
|
||||
IDummyTransformationSceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id)
|
||||
: ISceneNode(parent, mgr, id) {}
|
||||
IDummyTransformationSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id) :
|
||||
ISceneNode(parent, mgr, id) {}
|
||||
|
||||
//! Returns a reference to the current relative transformation matrix.
|
||||
/** This is the matrix, this scene node uses instead of scale, translation
|
||||
|
@ -308,7 +308,6 @@ namespace irr
|
||||
};
|
||||
} // end namespace gui
|
||||
|
||||
|
||||
//! SEvents hold information about an event. See irr::IEventReceiver for details on event handling.
|
||||
struct SEvent
|
||||
{
|
||||
@ -323,7 +322,6 @@ struct SEvent
|
||||
|
||||
//! Type of GUI Event
|
||||
gui::EGUI_EVENT_TYPE EventType;
|
||||
|
||||
};
|
||||
|
||||
//! Any kind of mouse event.
|
||||
@ -572,7 +570,6 @@ struct SEvent
|
||||
struct SSystemEvent SystemEvent;
|
||||
struct SApplicationEvent ApplicationEvent;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
//! Interface of an object which can receive events.
|
||||
@ -584,7 +581,6 @@ path it takes through the system. */
|
||||
class IEventReceiver
|
||||
{
|
||||
public:
|
||||
|
||||
//! Destructor
|
||||
virtual ~IEventReceiver() {}
|
||||
|
||||
@ -597,7 +593,6 @@ public:
|
||||
virtual bool OnEvent(const SEvent &event) = 0;
|
||||
};
|
||||
|
||||
|
||||
//! Information on a joystick, returned from @ref irr::IrrlichtDevice::activateJoysticks()
|
||||
struct SJoystickInfo
|
||||
{
|
||||
@ -634,5 +629,4 @@ struct SJoystickInfo
|
||||
} PovHat;
|
||||
}; // struct SJoystickInfo
|
||||
|
||||
|
||||
} // end namespace irr
|
||||
|
@ -40,7 +40,6 @@ enum E_FILE_ARCHIVE_TYPE
|
||||
class IFileArchive : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Opens a file based on its name
|
||||
/** Creates and returns a new IReadFile for a file in the archive.
|
||||
\param filename The file to open
|
||||
@ -124,6 +123,5 @@ public:
|
||||
virtual IFileArchive *createArchive(io::IReadFile *file, bool ignoreCase, bool ignorePaths) const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace io
|
||||
} // end namespace irr
|
||||
|
@ -21,7 +21,6 @@ class IWriteFile;
|
||||
class IFileList;
|
||||
class IAttributes;
|
||||
|
||||
|
||||
//! The FileSystem manages files and archives and provides access to them.
|
||||
/** It manages where files are, so that modules which use the the IO do not
|
||||
need to know where every file is located. A file could be in a .zip-Archive or
|
||||
@ -29,7 +28,6 @@ as file on disk, using the IFileSystem makes no difference to this. */
|
||||
class IFileSystem : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Opens a file for read access.
|
||||
/** \param filename: Name of file to open.
|
||||
\return Pointer to the created file interface.
|
||||
@ -77,7 +75,6 @@ public:
|
||||
*/
|
||||
virtual IWriteFile *createMemoryWriteFile(void *memory, s32 len, const path &fileName, bool deleteMemoryWhenDropped = false) = 0;
|
||||
|
||||
|
||||
//! Opens a file for write access.
|
||||
/** \param filename: Name of file to open.
|
||||
\param append: If the file already exist, all write operations are
|
||||
@ -264,6 +261,5 @@ public:
|
||||
virtual bool existFile(const path &filename) const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace io
|
||||
} // end namespace irr
|
||||
|
@ -27,7 +27,6 @@ class IShaderConstantSetCallBack;
|
||||
class IGPUProgrammingServices
|
||||
{
|
||||
public:
|
||||
|
||||
//! Destructor
|
||||
virtual ~IGPUProgrammingServices() {}
|
||||
|
||||
@ -366,6 +365,5 @@ public:
|
||||
virtual void deleteShaderMaterial(s32 material) = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
@ -108,10 +108,9 @@ namespace gui
|
||||
class IGUIButton : public IGUIElement
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IGUIButton(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_BUTTON, environment, parent, id, rectangle) {}
|
||||
IGUIButton(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_BUTTON, environment, parent, id, rectangle) {}
|
||||
|
||||
//! Sets another skin independent font.
|
||||
/** If this is set to zero, the button uses the font of the skin.
|
||||
@ -187,7 +186,6 @@ namespace gui
|
||||
\param sourceRect: Position in the texture, where the image is located */
|
||||
virtual void setPressedImage(video::ITexture *image, const core::rect<s32> &sourceRect) = 0;
|
||||
|
||||
|
||||
//! Sets the sprite bank used by the button
|
||||
/** NOTE: The spritebank itself is _not_ serialized so far. The sprites are serialized.
|
||||
Which means after loading the gui you still have to set the spritebank manually. */
|
||||
@ -259,6 +257,5 @@ namespace gui
|
||||
virtual bool getClickControlState() const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -18,10 +18,9 @@ namespace gui
|
||||
class IGUICheckBox : public IGUIElement
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IGUICheckBox(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_CHECK_BOX, environment, parent, id, rectangle) {}
|
||||
IGUICheckBox(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_CHECK_BOX, environment, parent, id, rectangle) {}
|
||||
|
||||
//! Set if box is checked.
|
||||
virtual void setChecked(bool checked) = 0;
|
||||
@ -42,7 +41,6 @@ namespace gui
|
||||
//! Checks if border drawing is enabled
|
||||
/** \return true if border drawing is enabled, false otherwise */
|
||||
virtual bool isDrawBorderEnabled() const = 0;
|
||||
|
||||
};
|
||||
|
||||
} // end namespace gui
|
||||
|
@ -18,10 +18,9 @@ namespace gui
|
||||
class IGUIComboBox : public IGUIElement
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IGUIComboBox(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_COMBO_BOX, environment, parent, id, rectangle) {}
|
||||
IGUIComboBox(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_COMBO_BOX, environment, parent, id, rectangle) {}
|
||||
|
||||
//! Returns amount of items in box
|
||||
virtual u32 getItemCount() const = 0;
|
||||
@ -69,6 +68,5 @@ namespace gui
|
||||
virtual u32 getMaxSelectionRows() const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -22,10 +22,9 @@ namespace gui
|
||||
class IGUIEditBox : public IGUIElement
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IGUIEditBox(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_EDIT_BOX, environment, parent, id, rectangle) {}
|
||||
IGUIEditBox(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_EDIT_BOX, environment, parent, id, rectangle) {}
|
||||
|
||||
//! Sets another skin independent font.
|
||||
/** If this is set to zero, the button uses the font of the skin.
|
||||
@ -148,6 +147,5 @@ namespace gui
|
||||
virtual irr::u32 getCursorBlinkTime() const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -25,11 +25,11 @@ namespace gui
|
||||
class IGUIElement : virtual public IReferenceCounted, public IEventReceiver
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor
|
||||
IGUIElement(EGUI_ELEMENT_TYPE type, IGUIEnvironment *environment, IGUIElement *parent,
|
||||
s32 id, const core::rect<s32>& rectangle)
|
||||
: Parent(0), RelativeRect(rectangle), AbsoluteRect(rectangle),
|
||||
s32 id, const core::rect<s32> &rectangle) :
|
||||
Parent(0),
|
||||
RelativeRect(rectangle), AbsoluteRect(rectangle),
|
||||
AbsoluteClippingRect(rectangle), DesiredRect(rectangle),
|
||||
MaxSize(0, 0), MinSize(1, 1), IsVisible(true), IsEnabled(true),
|
||||
IsSubElement(false), NoClip(false), ID(id), IsTabStop(false), TabOrder(-1), IsTabGroup(false),
|
||||
@ -41,14 +41,12 @@ public:
|
||||
#endif
|
||||
|
||||
// if we were given a parent to attach to
|
||||
if (parent)
|
||||
{
|
||||
if (parent) {
|
||||
parent->addChildToEnd(this);
|
||||
recalculateAbsolutePosition(true);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! Destructor
|
||||
virtual ~IGUIElement()
|
||||
{
|
||||
@ -58,7 +56,6 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! Returns parent of this element.
|
||||
IGUIElement *getParent() const
|
||||
{
|
||||
@ -71,13 +68,11 @@ public:
|
||||
return RelativeRect;
|
||||
}
|
||||
|
||||
|
||||
//! Sets the relative rectangle of this element.
|
||||
/** \param r The absolute position to set */
|
||||
void setRelativePosition(const core::rect<s32> &r)
|
||||
{
|
||||
if (Parent)
|
||||
{
|
||||
if (Parent) {
|
||||
const core::rect<s32> &r2 = Parent->getAbsolutePosition();
|
||||
|
||||
core::dimension2df d((f32)(r2.getSize().Width), (f32)(r2.getSize().Height));
|
||||
@ -106,7 +101,6 @@ public:
|
||||
setRelativePosition(rectangle);
|
||||
}
|
||||
|
||||
|
||||
//! Sets the relative rectangle of this element as a proportion of its parent's area.
|
||||
/** \note This method used to be 'void setRelativePosition(const core::rect<f32>& r)'
|
||||
\param r The rectangle to set, interpreted as a proportion of the parent's area.
|
||||
@ -130,21 +124,18 @@ public:
|
||||
updateAbsolutePosition();
|
||||
}
|
||||
|
||||
|
||||
//! Gets the absolute rectangle of this element
|
||||
core::rect<s32> getAbsolutePosition() const
|
||||
{
|
||||
return AbsoluteRect;
|
||||
}
|
||||
|
||||
|
||||
//! Returns the visible area of the element.
|
||||
core::rect<s32> getAbsoluteClippingRect() const
|
||||
{
|
||||
return AbsoluteClippingRect;
|
||||
}
|
||||
|
||||
|
||||
//! Sets whether the element will ignore its parent's clipping rectangle
|
||||
/** \param noClip If true, the element will not be clipped by its parent's clipping rectangle. */
|
||||
void setNotClipped(bool noClip)
|
||||
@ -153,7 +144,6 @@ public:
|
||||
updateAbsolutePosition();
|
||||
}
|
||||
|
||||
|
||||
//! Gets whether the element will ignore its parent's clipping rectangle
|
||||
/** \return true if the element is not clipped by its parent's clipping rectangle. */
|
||||
bool isNotClipped() const
|
||||
@ -161,7 +151,6 @@ public:
|
||||
return NoClip;
|
||||
}
|
||||
|
||||
|
||||
//! Sets the maximum size allowed for this element
|
||||
/** If set to 0,0, there is no maximum size */
|
||||
void setMaxSize(core::dimension2du size)
|
||||
@ -170,7 +159,6 @@ public:
|
||||
updateAbsolutePosition();
|
||||
}
|
||||
|
||||
|
||||
//! Sets the minimum size allowed for this element
|
||||
void setMinSize(core::dimension2du size)
|
||||
{
|
||||
@ -182,7 +170,6 @@ public:
|
||||
updateAbsolutePosition();
|
||||
}
|
||||
|
||||
|
||||
//! The alignment defines how the borders of this element will be positioned when the parent element is resized.
|
||||
void setAlignment(EGUI_ALIGNMENT left, EGUI_ALIGNMENT right, EGUI_ALIGNMENT top, EGUI_ALIGNMENT bottom)
|
||||
{
|
||||
@ -191,8 +178,7 @@ public:
|
||||
AlignTop = top;
|
||||
AlignBottom = bottom;
|
||||
|
||||
if (Parent)
|
||||
{
|
||||
if (Parent) {
|
||||
core::rect<s32> r(Parent->getAbsolutePosition());
|
||||
|
||||
core::dimension2df d((f32)r.getSize().Width, (f32)r.getSize().Height);
|
||||
@ -238,13 +224,11 @@ public:
|
||||
recalculateAbsolutePosition(false);
|
||||
|
||||
// update all children
|
||||
for (auto child : Children)
|
||||
{
|
||||
for (auto child : Children) {
|
||||
child->updateAbsolutePosition();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! Returns the topmost GUI element at the specific position.
|
||||
/**
|
||||
This will check this GUI element and all of its descendants, so it
|
||||
@ -261,14 +245,12 @@ public:
|
||||
{
|
||||
IGUIElement *target = 0;
|
||||
|
||||
if (isVisible())
|
||||
{
|
||||
if (isVisible()) {
|
||||
// we have to search from back to front, because later children
|
||||
// might be drawn over the top of earlier ones.
|
||||
auto it = Children.rbegin();
|
||||
auto ie = Children.rend();
|
||||
while (it != ie)
|
||||
{
|
||||
while (it != ie) {
|
||||
target = (*it)->getElementFromPoint(point);
|
||||
if (target)
|
||||
return target;
|
||||
@ -283,7 +265,6 @@ public:
|
||||
return target;
|
||||
}
|
||||
|
||||
|
||||
//! Returns true if a point is within this element.
|
||||
/** Elements with a shape other than a rectangle should override this method */
|
||||
virtual bool isPointInside(const core::position2d<s32> &point) const
|
||||
@ -291,12 +272,10 @@ public:
|
||||
return AbsoluteClippingRect.isPointInside(point);
|
||||
}
|
||||
|
||||
|
||||
//! Adds a GUI element as new child of this element.
|
||||
virtual void addChild(IGUIElement *child)
|
||||
{
|
||||
if ( child && child != this )
|
||||
{
|
||||
if (child && child != this) {
|
||||
addChildToEnd(child);
|
||||
child->updateAbsolutePosition();
|
||||
}
|
||||
@ -312,7 +291,8 @@ public:
|
||||
}
|
||||
|
||||
//! Removes all children.
|
||||
virtual void removeAllChildren() {
|
||||
virtual void removeAllChildren()
|
||||
{
|
||||
while (!Children.empty()) {
|
||||
auto child = Children.back();
|
||||
child->remove();
|
||||
@ -326,36 +306,30 @@ public:
|
||||
Parent->removeChild(this);
|
||||
}
|
||||
|
||||
|
||||
//! Draws the element and its children.
|
||||
virtual void draw()
|
||||
{
|
||||
if ( isVisible() )
|
||||
{
|
||||
if (isVisible()) {
|
||||
for (auto child : Children)
|
||||
child->draw();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! animate the element and its children.
|
||||
virtual void OnPostRender(u32 timeMs)
|
||||
{
|
||||
if ( isVisible() )
|
||||
{
|
||||
if (isVisible()) {
|
||||
for (auto child : Children)
|
||||
child->OnPostRender(timeMs);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! Moves this element.
|
||||
virtual void move(core::position2d<s32> absoluteMovement)
|
||||
{
|
||||
setRelativePosition(DesiredRect + absoluteMovement);
|
||||
}
|
||||
|
||||
|
||||
//! Returns true if element is visible.
|
||||
virtual bool isVisible() const
|
||||
{
|
||||
@ -382,14 +356,12 @@ public:
|
||||
IsVisible = visible;
|
||||
}
|
||||
|
||||
|
||||
//! Returns true if this element was created as part of its parent control
|
||||
virtual bool isSubElement() const
|
||||
{
|
||||
return IsSubElement;
|
||||
}
|
||||
|
||||
|
||||
//! Sets whether this control was created as part of its parent.
|
||||
/** For example, it is true when a scrollbar is part of a listbox.
|
||||
SubElements are not saved to disk when calling guiEnvironment->saveGUI() */
|
||||
@ -398,7 +370,6 @@ public:
|
||||
IsSubElement = subElement;
|
||||
}
|
||||
|
||||
|
||||
//! If set to true, the focus will visit this element when using the tab key to cycle through elements.
|
||||
/** If this element is a tab group (see isTabGroup/setTabGroup) then
|
||||
ctrl+tab will be used instead. */
|
||||
@ -407,51 +378,43 @@ public:
|
||||
IsTabStop = enable;
|
||||
}
|
||||
|
||||
|
||||
//! Returns true if this element can be focused by navigating with the tab key
|
||||
bool isTabStop() const
|
||||
{
|
||||
return IsTabStop;
|
||||
}
|
||||
|
||||
|
||||
//! Sets the priority of focus when using the tab key to navigate between a group of elements.
|
||||
/** See setTabGroup, isTabGroup and getTabGroup for information on tab groups.
|
||||
Elements with a lower number are focused first */
|
||||
void setTabOrder(s32 index)
|
||||
{
|
||||
// negative = autonumber
|
||||
if (index < 0)
|
||||
{
|
||||
if (index < 0) {
|
||||
TabOrder = 0;
|
||||
IGUIElement *el = getTabGroup();
|
||||
while (IsTabGroup && el && el->Parent)
|
||||
el = el->Parent;
|
||||
|
||||
IGUIElement *first = 0, *closest = 0;
|
||||
if (el)
|
||||
{
|
||||
if (el) {
|
||||
// find the highest element number
|
||||
el->getNextElement(-1, true, IsTabGroup, first, closest, true, true);
|
||||
if (first)
|
||||
{
|
||||
if (first) {
|
||||
TabOrder = first->getTabOrder() + 1;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
} else
|
||||
TabOrder = index;
|
||||
}
|
||||
|
||||
|
||||
//! Returns the number in the tab order sequence
|
||||
s32 getTabOrder() const
|
||||
{
|
||||
return TabOrder;
|
||||
}
|
||||
|
||||
|
||||
//! Sets whether this element is a container for a group of elements which can be navigated using the tab key.
|
||||
/** For example, windows are tab groups.
|
||||
Groups can be navigated using ctrl+tab, providing isTabStop is true. */
|
||||
@ -460,14 +423,12 @@ public:
|
||||
IsTabGroup = isGroup;
|
||||
}
|
||||
|
||||
|
||||
//! Returns true if this element is a tab group.
|
||||
bool isTabGroup() const
|
||||
{
|
||||
return IsTabGroup;
|
||||
}
|
||||
|
||||
|
||||
//! Returns the container element which holds all elements in this element's tab group.
|
||||
IGUIElement *getTabGroup()
|
||||
{
|
||||
@ -479,7 +440,6 @@ public:
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
//! Returns true if element is enabled
|
||||
/** Currently elements do _not_ care about parent-states.
|
||||
So if you want to affect children you have to enable/disable them all.
|
||||
@ -493,63 +453,54 @@ public:
|
||||
return IsEnabled;
|
||||
}
|
||||
|
||||
|
||||
//! Sets the enabled state of this element.
|
||||
virtual void setEnabled(bool enabled)
|
||||
{
|
||||
IsEnabled = enabled;
|
||||
}
|
||||
|
||||
|
||||
//! Sets the new caption of this element.
|
||||
virtual void setText(const wchar_t *text)
|
||||
{
|
||||
Text = text;
|
||||
}
|
||||
|
||||
|
||||
//! Returns caption of this element.
|
||||
virtual const wchar_t *getText() const
|
||||
{
|
||||
return Text.c_str();
|
||||
}
|
||||
|
||||
|
||||
//! Sets the new caption of this element.
|
||||
virtual void setToolTipText(const wchar_t *text)
|
||||
{
|
||||
ToolTipText = text;
|
||||
}
|
||||
|
||||
|
||||
//! Returns caption of this element.
|
||||
virtual const core::stringw &getToolTipText() const
|
||||
{
|
||||
return ToolTipText;
|
||||
}
|
||||
|
||||
|
||||
//! Returns id. Can be used to identify the element.
|
||||
virtual s32 getID() const
|
||||
{
|
||||
return ID;
|
||||
}
|
||||
|
||||
|
||||
//! Sets the id of this element
|
||||
virtual void setID(s32 id)
|
||||
{
|
||||
ID = id;
|
||||
}
|
||||
|
||||
|
||||
//! Called if an event happened.
|
||||
bool OnEvent(const SEvent &event) override
|
||||
{
|
||||
return Parent ? Parent->OnEvent(event) : false;
|
||||
}
|
||||
|
||||
|
||||
//! Brings a child to front
|
||||
/** \return True if successful, false if not. */
|
||||
virtual bool bringToFront(IGUIElement *child)
|
||||
@ -563,7 +514,6 @@ public:
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//! Moves a child to the back, so it's siblings are drawn on top of it
|
||||
/** \return True if successful, false if not. */
|
||||
virtual bool sendToBack(IGUIElement *child)
|
||||
@ -583,7 +533,6 @@ public:
|
||||
return Children;
|
||||
}
|
||||
|
||||
|
||||
//! Finds the first element with the given id.
|
||||
/** \param id: Id to search for.
|
||||
\param searchchildren: Set this to true, if also children of this
|
||||
@ -595,8 +544,7 @@ public:
|
||||
{
|
||||
IGUIElement *e = 0;
|
||||
|
||||
for (auto child : Children)
|
||||
{
|
||||
for (auto child : Children) {
|
||||
if (child->getID() == id)
|
||||
return child;
|
||||
|
||||
@ -610,25 +558,21 @@ public:
|
||||
return e;
|
||||
}
|
||||
|
||||
|
||||
//! returns true if the given element is a child of this one.
|
||||
//! \param child: The child element to check
|
||||
bool isMyChild(IGUIElement *child) const
|
||||
{
|
||||
if (!child)
|
||||
return false;
|
||||
do
|
||||
{
|
||||
do {
|
||||
if (child->Parent)
|
||||
child = child->Parent;
|
||||
|
||||
} while (child->Parent && child != this);
|
||||
|
||||
|
||||
return child == this;
|
||||
}
|
||||
|
||||
|
||||
//! searches elements to find the closest next element to tab to
|
||||
/** \param startOrder: The TabOrder of the current element, -1 if none
|
||||
\param reverse: true if searching for a lower number
|
||||
@ -651,62 +595,46 @@ public:
|
||||
|
||||
s32 closestOrder, currentOrder;
|
||||
|
||||
while(it != Children.end())
|
||||
{
|
||||
while (it != Children.end()) {
|
||||
// ignore invisible elements and their children
|
||||
if (((*it)->isVisible() || includeInvisible) &&
|
||||
(group == true || (*it)->isTabGroup() == false) )
|
||||
{
|
||||
(group == true || (*it)->isTabGroup() == false)) {
|
||||
// ignore disabled, but children are checked (disabled is currently per element ignoring parent states)
|
||||
if ( (*it)->isEnabled() || includeDisabled )
|
||||
{
|
||||
if ((*it)->isEnabled() || includeDisabled) {
|
||||
// only check tab stops and those with the same group status
|
||||
if ((*it)->isTabStop() && ((*it)->isTabGroup() == group))
|
||||
{
|
||||
if ((*it)->isTabStop() && ((*it)->isTabGroup() == group)) {
|
||||
currentOrder = (*it)->getTabOrder();
|
||||
|
||||
// is this what we're looking for?
|
||||
if (currentOrder == wanted)
|
||||
{
|
||||
if (currentOrder == wanted) {
|
||||
closest = *it;
|
||||
return true;
|
||||
}
|
||||
|
||||
// is it closer than the current closest?
|
||||
if (closest)
|
||||
{
|
||||
if (closest) {
|
||||
closestOrder = closest->getTabOrder();
|
||||
if ( ( reverse && currentOrder > closestOrder && currentOrder < startOrder)
|
||||
||(!reverse && currentOrder < closestOrder && currentOrder > startOrder))
|
||||
{
|
||||
if ((reverse && currentOrder > closestOrder && currentOrder < startOrder) || (!reverse && currentOrder < closestOrder && currentOrder > startOrder)) {
|
||||
closest = *it;
|
||||
}
|
||||
}
|
||||
else
|
||||
if ( (reverse && currentOrder < startOrder) || (!reverse && currentOrder > startOrder) )
|
||||
{
|
||||
} else if ((reverse && currentOrder < startOrder) || (!reverse && currentOrder > startOrder)) {
|
||||
closest = *it;
|
||||
}
|
||||
|
||||
// is it before the current first?
|
||||
if (first)
|
||||
{
|
||||
if (first) {
|
||||
closestOrder = first->getTabOrder();
|
||||
|
||||
if ( (reverse && closestOrder < currentOrder) || (!reverse && closestOrder > currentOrder) )
|
||||
{
|
||||
if ((reverse && closestOrder < currentOrder) || (!reverse && closestOrder > currentOrder)) {
|
||||
first = *it;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
first = *it;
|
||||
}
|
||||
}
|
||||
}
|
||||
// search within children
|
||||
if ((*it)->getNextElement(startOrder, reverse, group, first, closest, includeInvisible, includeDisabled))
|
||||
{
|
||||
if ((*it)->getNextElement(startOrder, reverse, group, first, closest, includeInvisible, includeDisabled)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -715,7 +643,6 @@ public:
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
//! Returns the type of the gui element.
|
||||
/** This is needed for the .NET wrapper but will be used
|
||||
later for serializing and deserializing.
|
||||
@ -740,7 +667,6 @@ public:
|
||||
return type == Type;
|
||||
}
|
||||
|
||||
|
||||
//! Returns the type name of the gui element.
|
||||
/** This is needed serializing elements. */
|
||||
virtual const c8 *getTypeName() const
|
||||
@ -755,7 +681,6 @@ public:
|
||||
return Name.c_str();
|
||||
}
|
||||
|
||||
|
||||
//! Sets the name of the element.
|
||||
/** \param name New name of the gui element. */
|
||||
virtual void setName(const c8 *name)
|
||||
@ -763,7 +688,6 @@ public:
|
||||
Name = name;
|
||||
}
|
||||
|
||||
|
||||
//! Sets the name of the element.
|
||||
/** \param name New name of the gui element. */
|
||||
virtual void setName(const core::stringc &name)
|
||||
@ -771,20 +695,17 @@ public:
|
||||
Name = name;
|
||||
}
|
||||
|
||||
|
||||
//! Returns whether the element takes input from the IME
|
||||
virtual bool acceptsIME()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
// not virtual because needed in constructor
|
||||
void addChildToEnd(IGUIElement *child)
|
||||
{
|
||||
if (child)
|
||||
{
|
||||
if (child) {
|
||||
child->grab(); // prevent destruction when removed
|
||||
child->remove(); // remove from old parent
|
||||
child->LastParentRect = getAbsolutePosition();
|
||||
@ -795,7 +716,8 @@ protected:
|
||||
|
||||
#ifndef NDEBUG
|
||||
template <typename Iterator>
|
||||
static size_t _fastSetChecksum(Iterator begin, Iterator end) {
|
||||
static size_t _fastSetChecksum(Iterator begin, Iterator end)
|
||||
{
|
||||
std::hash<typename Iterator::value_type> hasher;
|
||||
size_t checksum = 0;
|
||||
for (Iterator it = begin; it != end; ++it) {
|
||||
@ -813,8 +735,7 @@ protected:
|
||||
const std::vector<IGUIElement *> &neworder)
|
||||
{
|
||||
assert(_fastSetChecksum(from, to) == _fastSetChecksum(neworder.begin(), neworder.end()));
|
||||
for (auto e : neworder)
|
||||
{
|
||||
for (auto e : neworder) {
|
||||
*from = e;
|
||||
e->ParentPos = from;
|
||||
++from;
|
||||
@ -822,7 +743,6 @@ protected:
|
||||
assert(from == to);
|
||||
}
|
||||
|
||||
|
||||
// not virtual because needed in constructor
|
||||
void recalculateAbsolutePosition(bool recursive)
|
||||
{
|
||||
@ -830,18 +750,15 @@ protected:
|
||||
core::rect<s32> parentAbsoluteClip;
|
||||
f32 fw = 0.f, fh = 0.f;
|
||||
|
||||
if (Parent)
|
||||
{
|
||||
if (Parent) {
|
||||
parentAbsolute = Parent->AbsoluteRect;
|
||||
|
||||
if (NoClip)
|
||||
{
|
||||
if (NoClip) {
|
||||
IGUIElement *p = this;
|
||||
while (p->Parent)
|
||||
p = p->Parent;
|
||||
parentAbsoluteClip = p->AbsoluteClippingRect;
|
||||
}
|
||||
else
|
||||
} else
|
||||
parentAbsoluteClip = Parent->AbsoluteClippingRect;
|
||||
}
|
||||
|
||||
@ -854,8 +771,7 @@ protected:
|
||||
if (AlignTop == EGUIA_SCALE || AlignBottom == EGUIA_SCALE)
|
||||
fh = (f32)parentAbsolute.getHeight();
|
||||
|
||||
switch (AlignLeft)
|
||||
{
|
||||
switch (AlignLeft) {
|
||||
case EGUIA_UPPERLEFT:
|
||||
break;
|
||||
case EGUIA_LOWERRIGHT:
|
||||
@ -869,8 +785,7 @@ protected:
|
||||
break;
|
||||
}
|
||||
|
||||
switch (AlignRight)
|
||||
{
|
||||
switch (AlignRight) {
|
||||
case EGUIA_UPPERLEFT:
|
||||
break;
|
||||
case EGUIA_LOWERRIGHT:
|
||||
@ -884,8 +799,7 @@ protected:
|
||||
break;
|
||||
}
|
||||
|
||||
switch (AlignTop)
|
||||
{
|
||||
switch (AlignTop) {
|
||||
case EGUIA_UPPERLEFT:
|
||||
break;
|
||||
case EGUIA_LOWERRIGHT:
|
||||
@ -899,8 +813,7 @@ protected:
|
||||
break;
|
||||
}
|
||||
|
||||
switch (AlignBottom)
|
||||
{
|
||||
switch (AlignBottom) {
|
||||
case EGUIA_UPPERLEFT:
|
||||
break;
|
||||
case EGUIA_LOWERRIGHT:
|
||||
@ -941,18 +854,15 @@ protected:
|
||||
|
||||
LastParentRect = parentAbsolute;
|
||||
|
||||
if ( recursive )
|
||||
{
|
||||
if (recursive) {
|
||||
// update all children
|
||||
for (auto child : Children)
|
||||
{
|
||||
for (auto child : Children) {
|
||||
child->recalculateAbsolutePosition(recursive);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
//! List of all children of this element
|
||||
std::list<IGUIElement *> Children;
|
||||
|
||||
@ -1027,6 +937,5 @@ protected:
|
||||
EGUI_ELEMENT_TYPE Type;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -58,7 +58,6 @@ class IGUIWindow;
|
||||
class IGUIEnvironment : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Draws all gui elements by traversing the GUI environment starting at the root node.
|
||||
/** \param When true ensure the GuiEnvironment (aka the RootGUIElement) has the same size as the current driver screensize.
|
||||
Can be set to false to control that size yourself, p.E when not the full size should be used for UI. */
|
||||
@ -152,7 +151,6 @@ public:
|
||||
See IReferenceCounted::drop() for more information. */
|
||||
virtual IGUISkin *createSkin(EGUI_SKIN_TYPE type) = 0;
|
||||
|
||||
|
||||
//! Creates the image list from the given texture.
|
||||
/** \param texture Texture to split into images
|
||||
\param imageSize Dimension of each image
|
||||
@ -412,6 +410,5 @@ public:
|
||||
virtual void addToDeletionQueue(IGUIElement *element) = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -23,10 +23,9 @@ namespace gui
|
||||
class IGUIFileOpenDialog : public IGUIElement
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IGUIFileOpenDialog(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_FILE_OPEN_DIALOG, environment, parent, id, rectangle) {}
|
||||
IGUIFileOpenDialog(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_FILE_OPEN_DIALOG, environment, parent, id, rectangle) {}
|
||||
|
||||
//! Returns the filename of the selected file converted to wide characters. Returns NULL if no file was selected.
|
||||
virtual const wchar_t *getFileName() const = 0;
|
||||
@ -41,6 +40,5 @@ namespace gui
|
||||
virtual const wchar_t *getDirectoryNameW() const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -38,7 +38,6 @@ enum EGUI_FONT_TYPE
|
||||
class IGUIFont : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Draws some text and clips it to the specified rectangle if wanted.
|
||||
/** \param text: Text to draw
|
||||
\param position: Rectangle specifying position where to draw the text.
|
||||
|
@ -16,7 +16,6 @@ namespace gui
|
||||
class IGUIFontBitmap : public IGUIFont
|
||||
{
|
||||
public:
|
||||
|
||||
//! Returns the type of this font
|
||||
EGUI_FONT_TYPE getType() const override { return EGFT_BITMAP; }
|
||||
|
||||
|
@ -18,10 +18,9 @@ namespace gui
|
||||
class IGUIImage : public IGUIElement
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IGUIImage(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_IMAGE, environment, parent, id, rectangle) {}
|
||||
IGUIImage(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_IMAGE, environment, parent, id, rectangle) {}
|
||||
|
||||
//! Sets an image texture
|
||||
virtual void setImage(video::ITexture *image) = 0;
|
||||
@ -79,6 +78,5 @@ namespace gui
|
||||
virtual bool isDrawBackgroundEnabled() const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -16,7 +16,6 @@ namespace gui
|
||||
class IGUIImageList : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Destructor
|
||||
virtual ~IGUIImageList(){};
|
||||
|
||||
|
@ -29,7 +29,6 @@ namespace gui
|
||||
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
|
||||
@ -39,8 +38,8 @@ namespace gui
|
||||
{
|
||||
public:
|
||||
//! constructor
|
||||
IGUIListBox(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_LIST_BOX, environment, parent, id, rectangle) {}
|
||||
IGUIListBox(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_LIST_BOX, environment, parent, id, rectangle) {}
|
||||
|
||||
//! returns amount of list items
|
||||
virtual u32 getItemCount() const = 0;
|
||||
@ -133,6 +132,5 @@ namespace gui
|
||||
virtual IGUIScrollBar *getVerticalScrollBar() const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -18,10 +18,9 @@ namespace gui
|
||||
class IGUIScrollBar : public IGUIElement
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IGUIScrollBar(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_SCROLL_BAR, environment, parent, id, rectangle) {}
|
||||
IGUIScrollBar(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_SCROLL_BAR, environment, parent, id, rectangle) {}
|
||||
|
||||
//! sets the maximum value of the scrollbar.
|
||||
virtual void setMax(s32 max) = 0;
|
||||
@ -56,6 +55,5 @@ namespace gui
|
||||
virtual void setPos(s32 pos) = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -54,7 +54,6 @@ namespace gui
|
||||
0,
|
||||
};
|
||||
|
||||
|
||||
//! Enumeration for skin colors
|
||||
enum EGUI_DEFAULT_COLOR
|
||||
{
|
||||
@ -200,7 +199,6 @@ namespace gui
|
||||
EGDS_COUNT
|
||||
};
|
||||
|
||||
|
||||
//! Names for default skin sizes
|
||||
const c8 *const GUISkinSizeNames[EGDS_COUNT + 1] =
|
||||
{
|
||||
@ -227,9 +225,7 @@ namespace gui
|
||||
"ButtonPressedTextOffsetY",
|
||||
"ButtonPressedSpriteOffsetX",
|
||||
"ButtonPressedSpriteOffsetY",
|
||||
0
|
||||
};
|
||||
|
||||
0};
|
||||
|
||||
enum EGUI_DEFAULT_TEXT
|
||||
{
|
||||
@ -265,8 +261,7 @@ namespace gui
|
||||
"WindowButtonMaximize",
|
||||
"WindowButtonMinimize",
|
||||
"WindowButtonRestore",
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
//! Customizable symbols for GUI
|
||||
enum EGUI_DEFAULT_ICON
|
||||
@ -348,8 +343,7 @@ namespace gui
|
||||
"collapse",
|
||||
"file",
|
||||
"directory",
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
// Customizable fonts
|
||||
enum EGUI_DEFAULT_FONT
|
||||
@ -376,14 +370,12 @@ namespace gui
|
||||
"windowFont",
|
||||
"menuFont",
|
||||
"tooltipFont",
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
//! A skin modifies the look of the GUI elements.
|
||||
class IGUISkin : virtual public IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! returns default color
|
||||
virtual video::SColor getColor(EGUI_DEFAULT_COLOR color) const = 0;
|
||||
|
||||
@ -571,6 +563,5 @@ namespace gui
|
||||
virtual EGUI_SKIN_TYPE getType() const { return EGST_UNKNOWN; }
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -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
|
||||
struct SGUISpriteFrame
|
||||
{
|
||||
SGUISpriteFrame() : textureNumber(0), rectNumber(0)
|
||||
SGUISpriteFrame() :
|
||||
textureNumber(0), rectNumber(0)
|
||||
{
|
||||
}
|
||||
|
||||
SGUISpriteFrame(u32 textureIndex, u32 positionIndex)
|
||||
: textureNumber(textureIndex), rectNumber(positionIndex)
|
||||
SGUISpriteFrame(u32 textureIndex, u32 positionIndex) :
|
||||
textureNumber(textureIndex), rectNumber(positionIndex)
|
||||
{
|
||||
}
|
||||
|
||||
@ -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
|
||||
struct SGUISprite
|
||||
{
|
||||
SGUISprite() : frameTime(0) {}
|
||||
SGUISprite(const SGUISpriteFrame& firstFrame) : frameTime(0)
|
||||
SGUISprite() :
|
||||
frameTime(0) {}
|
||||
SGUISprite(const SGUISpriteFrame &firstFrame) :
|
||||
frameTime(0)
|
||||
{
|
||||
Frames.push_back(firstFrame);
|
||||
}
|
||||
@ -54,7 +57,6 @@ struct SGUISprite
|
||||
u32 frameTime;
|
||||
};
|
||||
|
||||
|
||||
//! Sprite bank interface.
|
||||
/** See http://http://irrlicht.sourceforge.net/forum//viewtopic.php?f=9&t=25742
|
||||
* for more information how to use the spritebank.
|
||||
@ -62,7 +64,6 @@ struct SGUISprite
|
||||
class IGUISpriteBank : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Returns the list of rectangles held by the sprite bank
|
||||
virtual core::array<core::rect<s32>> &getPositions() = 0;
|
||||
|
||||
@ -133,6 +134,5 @@ public:
|
||||
bool loop = true, bool center = false) = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -17,10 +17,9 @@ namespace gui
|
||||
class IGUIStaticText : public IGUIElement
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IGUIStaticText(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_STATIC_TEXT, environment, parent, id, rectangle) {}
|
||||
IGUIStaticText(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_STATIC_TEXT, environment, parent, id, rectangle) {}
|
||||
|
||||
//! Sets another skin independent font.
|
||||
/** If this is set to zero, the button uses the font of the skin.
|
||||
@ -130,6 +129,5 @@ namespace gui
|
||||
virtual bool isRightToLeft() const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -21,10 +21,9 @@ namespace gui
|
||||
class IGUITabControl : public IGUIElement
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IGUITabControl(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_TAB_CONTROL, environment, parent, id, rectangle) {}
|
||||
IGUITabControl(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_TAB_CONTROL, environment, parent, id, rectangle) {}
|
||||
|
||||
//! Adds a tab
|
||||
virtual IGUITab *addTab(const wchar_t *caption, s32 id = -1) = 0;
|
||||
@ -123,10 +122,9 @@ namespace gui
|
||||
class IGUITab : public IGUIElement
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IGUITab(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_TAB, environment, parent, id, rectangle) {}
|
||||
IGUITab(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_TAB, environment, parent, id, rectangle) {}
|
||||
|
||||
//! sets if the tab should draw its background
|
||||
virtual void setDrawBackground(bool draw = true) = 0;
|
||||
|
@ -20,10 +20,9 @@ namespace gui
|
||||
class IGUIToolBar : public IGUIElement
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IGUIToolBar(IGUIEnvironment* environment, IGUIElement* parent, s32 id, core::rect<s32> rectangle)
|
||||
: IGUIElement(EGUIET_TOOL_BAR, environment, parent, id, rectangle) {}
|
||||
IGUIToolBar(IGUIEnvironment *environment, IGUIElement *parent, s32 id, core::rect<s32> rectangle) :
|
||||
IGUIElement(EGUIET_TOOL_BAR, environment, parent, id, rectangle) {}
|
||||
|
||||
//! Adds a button to the tool bar
|
||||
virtual IGUIButton *addButton(s32 id = -1, const wchar_t *text = 0, const wchar_t *tooltiptext = 0,
|
||||
@ -31,6 +30,5 @@ namespace gui
|
||||
bool isPushButton = false, bool useAlphaChannel = false) = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace gui
|
||||
} // end namespace irr
|
||||
|
@ -23,7 +23,6 @@ NOTE: Floating point formats are not well supported yet. Basically only getData(
|
||||
class IImage : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IImage(ECOLOR_FORMAT format, const core::dimension2d<u32> &size, bool deleteMemory) :
|
||||
Format(format), Size(size), Data(0), MipMapsData(0), BytesPerPixel(0), Pitch(0), DeleteMemory(deleteMemory), DeleteMipMapsMemory(false)
|
||||
@ -88,8 +87,7 @@ public:
|
||||
//! Returns mask for red value of a pixel
|
||||
u32 getRedMask() const
|
||||
{
|
||||
switch (Format)
|
||||
{
|
||||
switch (Format) {
|
||||
case ECF_A1R5G5B5:
|
||||
return 0x1F << 10;
|
||||
case ECF_R5G6B5:
|
||||
@ -106,8 +104,7 @@ public:
|
||||
//! Returns mask for green value of a pixel
|
||||
u32 getGreenMask() const
|
||||
{
|
||||
switch (Format)
|
||||
{
|
||||
switch (Format) {
|
||||
case ECF_A1R5G5B5:
|
||||
return 0x1F << 5;
|
||||
case ECF_R5G6B5:
|
||||
@ -124,8 +121,7 @@ public:
|
||||
//! Returns mask for blue value of a pixel
|
||||
u32 getBlueMask() const
|
||||
{
|
||||
switch (Format)
|
||||
{
|
||||
switch (Format) {
|
||||
case ECF_A1R5G5B5:
|
||||
return 0x1F;
|
||||
case ECF_R5G6B5:
|
||||
@ -142,8 +138,7 @@ public:
|
||||
//! Returns mask for alpha value of a pixel
|
||||
u32 getAlphaMask() const
|
||||
{
|
||||
switch (Format)
|
||||
{
|
||||
switch (Format) {
|
||||
case ECF_A1R5G5B5:
|
||||
return 0x1 << 15;
|
||||
case ECF_R5G6B5:
|
||||
@ -175,15 +170,13 @@ public:
|
||||
return getMipMapsSize(Size, mipmapLevel);
|
||||
}
|
||||
|
||||
|
||||
//! Calculate mipmap size for a certain level
|
||||
/** level 0 will be full image size. Every further level is half the size. */
|
||||
static core::dimension2du getMipMapsSize(const core::dimension2du &sizeLevel0, u32 mipmapLevel)
|
||||
{
|
||||
core::dimension2du result(sizeLevel0);
|
||||
u32 i = 0;
|
||||
while (i != mipmapLevel)
|
||||
{
|
||||
while (i != mipmapLevel) {
|
||||
if (result.Width > 1)
|
||||
result.Width >>= 1;
|
||||
if (result.Height > 1)
|
||||
@ -196,7 +189,6 @@ public:
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
//! Get mipmaps data.
|
||||
/** Note that different mip levels are just behind each other in memory block.
|
||||
So if you just get level 1 you also have the data for all other levels.
|
||||
@ -204,14 +196,12 @@ public:
|
||||
*/
|
||||
void *getMipMapsData(irr::u32 mipLevel = 1) const
|
||||
{
|
||||
if ( MipMapsData && mipLevel > 0)
|
||||
{
|
||||
if (MipMapsData && mipLevel > 0) {
|
||||
size_t dataSize = 0;
|
||||
core::dimension2du mipSize(Size);
|
||||
u32 i = 1; // We want the start of data for this level, not end.
|
||||
|
||||
while (i != mipLevel)
|
||||
{
|
||||
while (i != mipLevel) {
|
||||
if (mipSize.Width > 1)
|
||||
mipSize.Width >>= 1;
|
||||
|
||||
@ -242,31 +232,24 @@ public:
|
||||
destruction. */
|
||||
void setMipMapsData(void *data, bool ownForeignMemory)
|
||||
{
|
||||
if (data != MipMapsData)
|
||||
{
|
||||
if (DeleteMipMapsMemory)
|
||||
{
|
||||
if (data != MipMapsData) {
|
||||
if (DeleteMipMapsMemory) {
|
||||
delete[] MipMapsData;
|
||||
|
||||
DeleteMipMapsMemory = false;
|
||||
}
|
||||
|
||||
if (data)
|
||||
{
|
||||
if (ownForeignMemory)
|
||||
{
|
||||
if (data) {
|
||||
if (ownForeignMemory) {
|
||||
MipMapsData = static_cast<u8 *>(data);
|
||||
|
||||
DeleteMipMapsMemory = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
u32 dataSize = 0;
|
||||
u32 width = Size.Width;
|
||||
u32 height = Size.Height;
|
||||
|
||||
do
|
||||
{
|
||||
do {
|
||||
if (width > 1)
|
||||
width >>= 1;
|
||||
|
||||
@ -281,9 +264,7 @@ public:
|
||||
|
||||
DeleteMipMapsMemory = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
MipMapsData = 0;
|
||||
}
|
||||
}
|
||||
@ -336,8 +317,7 @@ public:
|
||||
//! get the amount of Bits per Pixel of the given color format
|
||||
static u32 getBitsPerPixelFromFormat(const ECOLOR_FORMAT format)
|
||||
{
|
||||
switch(format)
|
||||
{
|
||||
switch (format) {
|
||||
case ECF_A1R5G5B5:
|
||||
return 16;
|
||||
case ECF_R5G6B5:
|
||||
@ -396,8 +376,7 @@ public:
|
||||
//! check if the color format is only viable for depth/stencil textures
|
||||
static bool isDepthFormat(const ECOLOR_FORMAT format)
|
||||
{
|
||||
switch(format)
|
||||
{
|
||||
switch (format) {
|
||||
case ECF_D16:
|
||||
case ECF_D32:
|
||||
case ECF_D24S8:
|
||||
@ -413,8 +392,7 @@ public:
|
||||
if (isCompressedFormat(format))
|
||||
return false;
|
||||
|
||||
switch(format)
|
||||
{
|
||||
switch (format) {
|
||||
case ECF_R16F:
|
||||
case ECF_G16R16F:
|
||||
case ECF_A16B16G16R16F:
|
||||
@ -442,6 +420,5 @@ protected:
|
||||
bool DeleteMipMapsMemory;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
@ -27,7 +27,6 @@ IVideoDriver::addExternalImageLoader() to the engine. */
|
||||
class IImageLoader : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Check if the file might be loaded by this class
|
||||
/** Check is based on the file extension (e.g. ".tga")
|
||||
\param filename Name of file to check.
|
||||
@ -46,6 +45,5 @@ public:
|
||||
virtual IImage *loadImage(io::IReadFile *file) const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
@ -19,7 +19,6 @@ namespace video
|
||||
{
|
||||
class IImage;
|
||||
|
||||
|
||||
//! Interface for writing software image data.
|
||||
class IImageWriter : public IReferenceCounted
|
||||
{
|
||||
|
@ -23,7 +23,6 @@ namespace scene
|
||||
class IIndexBuffer : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
virtual void *getData() = 0;
|
||||
|
||||
virtual video::E_INDEX_TYPE getType() const = 0;
|
||||
@ -56,6 +55,5 @@ namespace scene
|
||||
virtual u32 getChangedID() const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -32,12 +32,10 @@ enum ELOG_LEVEL
|
||||
ELL_NONE
|
||||
};
|
||||
|
||||
|
||||
//! Interface for logging messages, warnings and errors
|
||||
class ILogger : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Destructor
|
||||
virtual ~ILogger() {}
|
||||
|
||||
|
@ -24,7 +24,6 @@ engine with new materials. */
|
||||
class IMaterialRenderer : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Called by the IVideoDriver implementation the let the renderer set its needed render states.
|
||||
/** This is called during the IVideoDriver::setMaterial() call.
|
||||
When overriding this, you can set some renderstates or for example a
|
||||
@ -98,6 +97,5 @@ public:
|
||||
virtual IShaderConstantSetCallBack *getShaderConstantSetCallBack() const { return 0; }
|
||||
};
|
||||
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
@ -14,12 +14,10 @@ namespace video
|
||||
|
||||
class IVideoDriver;
|
||||
|
||||
|
||||
//! Interface providing some methods for changing advanced, internal states of a IVideoDriver.
|
||||
class IMaterialRendererServices
|
||||
{
|
||||
public:
|
||||
|
||||
//! Destructor
|
||||
virtual ~IMaterialRendererServices() {}
|
||||
|
||||
|
@ -59,7 +59,6 @@ namespace scene
|
||||
EAMT_STATIC
|
||||
};
|
||||
|
||||
|
||||
class IMeshBuffer;
|
||||
|
||||
//! Class which holds the geometry of an object.
|
||||
@ -70,7 +69,6 @@ namespace scene
|
||||
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;
|
||||
|
@ -38,7 +38,6 @@ namespace scene
|
||||
class IMeshBuffer : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Get the material of this meshbuffer
|
||||
/** \return Material of this buffer. */
|
||||
virtual video::SMaterial &getMaterial() = 0;
|
||||
@ -157,20 +156,26 @@ namespace scene
|
||||
virtual u32 getPrimitiveCount() const
|
||||
{
|
||||
const u32 indexCount = getIndexCount();
|
||||
switch (getPrimitiveType())
|
||||
{
|
||||
case scene::EPT_POINTS: return indexCount;
|
||||
case scene::EPT_LINE_STRIP: return indexCount-1;
|
||||
case scene::EPT_LINE_LOOP: return indexCount;
|
||||
case scene::EPT_LINES: return indexCount/2;
|
||||
case scene::EPT_TRIANGLE_STRIP: return (indexCount-2);
|
||||
case scene::EPT_TRIANGLE_FAN: return (indexCount-2);
|
||||
case scene::EPT_TRIANGLES: return indexCount/3;
|
||||
case scene::EPT_POINT_SPRITES: return indexCount;
|
||||
switch (getPrimitiveType()) {
|
||||
case scene::EPT_POINTS:
|
||||
return indexCount;
|
||||
case scene::EPT_LINE_STRIP:
|
||||
return indexCount - 1;
|
||||
case scene::EPT_LINE_LOOP:
|
||||
return indexCount;
|
||||
case scene::EPT_LINES:
|
||||
return indexCount / 2;
|
||||
case scene::EPT_TRIANGLE_STRIP:
|
||||
return (indexCount - 2);
|
||||
case scene::EPT_TRIANGLE_FAN:
|
||||
return (indexCount - 2);
|
||||
case scene::EPT_TRIANGLES:
|
||||
return indexCount / 3;
|
||||
case scene::EPT_POINT_SPRITES:
|
||||
return indexCount;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} // end namespace scene
|
||||
|
@ -26,7 +26,6 @@ namespace scene
|
||||
class IMeshCache : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Destructor
|
||||
virtual ~IMeshCache() {}
|
||||
|
||||
@ -128,6 +127,5 @@ namespace scene
|
||||
virtual void clearUnusedMeshes() = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -25,7 +25,6 @@ ISceneManager::addExternalMeshLoader() to the engine. */
|
||||
class IMeshLoader : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor
|
||||
IMeshLoader() {}
|
||||
|
||||
@ -47,6 +46,5 @@ public:
|
||||
virtual IAnimatedMesh *createMesh(io::IReadFile *file) = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -28,7 +28,6 @@ namespace scene
|
||||
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.
|
||||
@ -99,7 +98,6 @@ namespace scene
|
||||
return apply_(func, buffer, boundingBoxUpdate, func);
|
||||
}
|
||||
|
||||
|
||||
//! Apply a manipulator on the Mesh
|
||||
/** \param func A functor defining the mesh manipulation.
|
||||
\param mesh The Mesh to apply the manipulator to.
|
||||
@ -112,11 +110,9 @@ namespace scene
|
||||
return true;
|
||||
bool result = true;
|
||||
core::aabbox3df bufferbox;
|
||||
for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
|
||||
{
|
||||
for (u32 i = 0; i < mesh->getMeshBufferCount(); ++i) {
|
||||
result &= apply(func, mesh->getMeshBuffer(i), boundingBoxUpdate);
|
||||
if (boundingBoxUpdate)
|
||||
{
|
||||
if (boundingBoxUpdate) {
|
||||
if (0 == i)
|
||||
bufferbox.reset(mesh->getMeshBuffer(i)->getBoundingBox());
|
||||
else
|
||||
@ -142,31 +138,22 @@ protected:
|
||||
return true;
|
||||
|
||||
core::aabbox3df bufferbox;
|
||||
for (u32 i=0; i<buffer->getVertexCount(); ++i)
|
||||
{
|
||||
switch (buffer->getVertexType())
|
||||
{
|
||||
case video::EVT_STANDARD:
|
||||
{
|
||||
for (u32 i = 0; i < buffer->getVertexCount(); ++i) {
|
||||
switch (buffer->getVertexType()) {
|
||||
case video::EVT_STANDARD: {
|
||||
video::S3DVertex *verts = (video::S3DVertex *)buffer->getVertices();
|
||||
func(verts[i]);
|
||||
}
|
||||
break;
|
||||
case video::EVT_2TCOORDS:
|
||||
{
|
||||
} break;
|
||||
case video::EVT_2TCOORDS: {
|
||||
video::S3DVertex2TCoords *verts = (video::S3DVertex2TCoords *)buffer->getVertices();
|
||||
func(verts[i]);
|
||||
}
|
||||
break;
|
||||
case video::EVT_TANGENTS:
|
||||
{
|
||||
} break;
|
||||
case video::EVT_TANGENTS: {
|
||||
video::S3DVertexTangents *verts = (video::S3DVertexTangents *)buffer->getVertices();
|
||||
func(verts[i]);
|
||||
} break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (boundingBoxUpdate)
|
||||
{
|
||||
if (boundingBoxUpdate) {
|
||||
if (0 == i)
|
||||
bufferbox.reset(buffer->getPosition(0));
|
||||
else
|
||||
|
@ -13,20 +13,18 @@ namespace scene
|
||||
|
||||
class IMesh;
|
||||
|
||||
|
||||
//! A scene node displaying a static mesh
|
||||
class IMeshSceneNode : public ISceneNode
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor
|
||||
/** Use setMesh() to set the mesh to display.
|
||||
*/
|
||||
IMeshSceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id,
|
||||
const core::vector3df &position = core::vector3df(0, 0, 0),
|
||||
const core::vector3df &rotation = core::vector3df(0, 0, 0),
|
||||
const core::vector3df& scale = core::vector3df(1,1,1))
|
||||
: ISceneNode(parent, mgr, id, position, rotation, scale) {}
|
||||
const core::vector3df &scale = core::vector3df(1, 1, 1)) :
|
||||
ISceneNode(parent, mgr, id, position, rotation, scale) {}
|
||||
|
||||
//! Sets a new mesh to display
|
||||
/** \param mesh Mesh to display. */
|
||||
|
@ -40,7 +40,6 @@ public:
|
||||
\param availableBytes: will contain the available memory in Kilobytes (1024 B)
|
||||
\return True if successful, false if not */
|
||||
virtual bool getSystemMemory(u32 *totalBytes, u32 *availableBytes) const = 0;
|
||||
|
||||
};
|
||||
|
||||
} // end namespace
|
||||
|
@ -40,10 +40,9 @@ namespace irr
|
||||
class IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor.
|
||||
IReferenceCounted()
|
||||
: DebugName(0), ReferenceCounter(1)
|
||||
IReferenceCounted() :
|
||||
DebugName(0), ReferenceCounter(1)
|
||||
{
|
||||
}
|
||||
|
||||
@ -118,8 +117,7 @@ namespace irr
|
||||
_IRR_DEBUG_BREAK_IF(ReferenceCounter <= 0)
|
||||
|
||||
--ReferenceCounter;
|
||||
if (!ReferenceCounter)
|
||||
{
|
||||
if (!ReferenceCounter) {
|
||||
delete this;
|
||||
return true;
|
||||
}
|
||||
@ -144,7 +142,6 @@ namespace irr
|
||||
}
|
||||
|
||||
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.
|
||||
@ -155,7 +152,6 @@ namespace irr
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
//! The debug name.
|
||||
const c8 *DebugName;
|
||||
|
||||
|
@ -29,9 +29,9 @@ namespace video
|
||||
class IRenderTarget : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
IRenderTarget() : DepthStencil(0), DriverType(EDT_NULL)
|
||||
IRenderTarget() :
|
||||
DepthStencil(0), DriverType(EDT_NULL)
|
||||
{
|
||||
}
|
||||
|
||||
@ -69,12 +69,9 @@ namespace video
|
||||
//! You can pass getDepthStencil() for depthStencil if you don't want to change that one
|
||||
void setTexture(ITexture *texture, ITexture *depthStencil)
|
||||
{
|
||||
if ( texture )
|
||||
{
|
||||
if (texture) {
|
||||
setTextures(&texture, 1, depthStencil);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
setTextures(0, 0, depthStencil);
|
||||
}
|
||||
}
|
||||
@ -82,12 +79,9 @@ namespace video
|
||||
//! Set one cube surface texture.
|
||||
void setTexture(ITexture *texture, ITexture *depthStencil, E_CUBE_SURFACE cubeSurface)
|
||||
{
|
||||
if ( texture )
|
||||
{
|
||||
if (texture) {
|
||||
setTextures(&texture, 1, depthStencil, &cubeSurface, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
setTextures(0, 0, depthStencil, &cubeSurface, 1);
|
||||
}
|
||||
}
|
||||
@ -99,7 +93,6 @@ namespace video
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
//! Set multiple textures.
|
||||
// NOTE: working with pointers instead of arrays to avoid unnecessary memory allocations for the single textures case
|
||||
virtual void setTextures(ITexture *const *textures, u32 numTextures, ITexture *depthStencil, const E_CUBE_SURFACE *cubeSurfaces = 0, u32 numCubeSurfaces = 0) = 0;
|
||||
|
@ -18,7 +18,6 @@ namespace scene
|
||||
class ISceneCollisionManager : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Returns a 3d ray which would go through the 2d screen coordinates.
|
||||
/** \param pos: Screen coordinates in pixels.
|
||||
\param camera: Camera from which the ray starts. If null, the
|
||||
@ -28,7 +27,6 @@ namespace scene
|
||||
would be behind the 2d screen coordinates. */
|
||||
virtual core::line3d<f32> getRayFromScreenCoordinates(
|
||||
const core::position2d<s32> &pos, const ICameraSceneNode *camera = 0) = 0;
|
||||
|
||||
};
|
||||
|
||||
} // end namespace scene
|
||||
|
@ -126,7 +126,6 @@ namespace scene
|
||||
class ISceneManager : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Get pointer to an animatable mesh. Loads the file if not loaded already.
|
||||
/**
|
||||
* If you want to remove a loaded mesh from the cache again, use removeMesh().
|
||||
@ -629,6 +628,5 @@ namespace scene
|
||||
virtual bool isCulled(const ISceneNode *node) const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -38,13 +38,13 @@ namespace scene
|
||||
class ISceneNode : virtual public IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor
|
||||
ISceneNode(ISceneNode *parent, ISceneManager *mgr, s32 id = -1,
|
||||
const core::vector3df &position = core::vector3df(0, 0, 0),
|
||||
const core::vector3df &rotation = core::vector3df(0, 0, 0),
|
||||
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f))
|
||||
: RelativeTranslation(position), RelativeRotation(rotation), RelativeScale(scale),
|
||||
const core::vector3df &scale = core::vector3df(1.0f, 1.0f, 1.0f)) :
|
||||
RelativeTranslation(position),
|
||||
RelativeRotation(rotation), RelativeScale(scale),
|
||||
Parent(0), SceneManager(mgr), ID(id),
|
||||
AutomaticCullingState(EAC_BOX), DebugDataVisible(EDS_OFF),
|
||||
IsVisible(true), IsDebugObject(false)
|
||||
@ -55,7 +55,6 @@ namespace scene
|
||||
updateAbsolutePosition();
|
||||
}
|
||||
|
||||
|
||||
//! Destructor
|
||||
virtual ~ISceneNode()
|
||||
{
|
||||
@ -63,7 +62,6 @@ namespace scene
|
||||
removeAll();
|
||||
}
|
||||
|
||||
|
||||
//! This method is called just before the rendering process of the whole scene.
|
||||
/** Nodes may register themselves in the render pipeline during this call,
|
||||
precalculate the geometry which should be rendered, and prevent their
|
||||
@ -80,15 +78,13 @@ namespace scene
|
||||
*/
|
||||
virtual void OnRegisterSceneNode()
|
||||
{
|
||||
if (IsVisible)
|
||||
{
|
||||
if (IsVisible) {
|
||||
ISceneNodeList::iterator it = Children.begin();
|
||||
for (; it != Children.end(); ++it)
|
||||
(*it)->OnRegisterSceneNode();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! OnAnimate() is called just before rendering the whole scene.
|
||||
/** Nodes may calculate or store animations here, and may do other useful things,
|
||||
depending on what they are. Also, OnAnimate() should be called for all
|
||||
@ -97,8 +93,7 @@ namespace scene
|
||||
\param timeMs Current time in milliseconds. */
|
||||
virtual void OnAnimate(u32 timeMs)
|
||||
{
|
||||
if (IsVisible)
|
||||
{
|
||||
if (IsVisible) {
|
||||
// update absolute position
|
||||
updateAbsolutePosition();
|
||||
|
||||
@ -110,11 +105,9 @@ namespace scene
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! Renders the node.
|
||||
virtual void render() = 0;
|
||||
|
||||
|
||||
//! Returns the name of the node.
|
||||
/** \return Name as character string. */
|
||||
virtual const std::optional<std::string> &getName() const
|
||||
@ -129,7 +122,6 @@ namespace scene
|
||||
Name = name;
|
||||
}
|
||||
|
||||
|
||||
//! Get the axis aligned, not transformed bounding box of this node.
|
||||
/** This means that if this node is an animated 3d character,
|
||||
moving in a room, the bounding box will always be around the
|
||||
@ -140,7 +132,6 @@ namespace scene
|
||||
\return The non-transformed bounding box. */
|
||||
virtual const core::aabbox3d<f32> &getBoundingBox() const = 0;
|
||||
|
||||
|
||||
//! Get the axis aligned, transformed and animated absolute bounding box of this node.
|
||||
/** Note: The result is still an axis-aligned bounding box, so it's size
|
||||
changes with rotation.
|
||||
@ -177,7 +168,6 @@ namespace scene
|
||||
return AbsoluteTransformation;
|
||||
}
|
||||
|
||||
|
||||
//! Returns the relative transformation of the scene node.
|
||||
/** The relative transformation is stored internally as 3
|
||||
vectors: translation, rotation and scale. To get the relative
|
||||
@ -189,8 +179,7 @@ namespace scene
|
||||
mat.setRotationDegrees(RelativeRotation);
|
||||
mat.setTranslation(RelativeTranslation);
|
||||
|
||||
if (RelativeScale != core::vector3df(1.f,1.f,1.f))
|
||||
{
|
||||
if (RelativeScale != core::vector3df(1.f, 1.f, 1.f)) {
|
||||
core::matrix4 smat;
|
||||
smat.setScale(RelativeScale);
|
||||
mat *= smat;
|
||||
@ -199,7 +188,6 @@ namespace scene
|
||||
return mat;
|
||||
}
|
||||
|
||||
|
||||
//! Returns whether the node should be visible (if all of its parents are visible).
|
||||
/** This is only an option set by the user, but has nothing to
|
||||
do with geometry culling
|
||||
@ -234,7 +222,6 @@ namespace scene
|
||||
IsVisible = isVisible;
|
||||
}
|
||||
|
||||
|
||||
//! Get the id of the scene node.
|
||||
/** This id can be used to identify the node.
|
||||
\return The id. */
|
||||
@ -243,7 +230,6 @@ namespace scene
|
||||
return ID;
|
||||
}
|
||||
|
||||
|
||||
//! Sets the id of the scene node.
|
||||
/** This id can be used to identify the node.
|
||||
\param id The new id. */
|
||||
@ -252,15 +238,13 @@ namespace scene
|
||||
ID = id;
|
||||
}
|
||||
|
||||
|
||||
//! Adds a child to this scene node.
|
||||
/** If the scene node already has a parent it is first removed
|
||||
from the other parent.
|
||||
\param child A pointer to the new child. */
|
||||
virtual void addChild(ISceneNode *child)
|
||||
{
|
||||
if (child && (child != this))
|
||||
{
|
||||
if (child && (child != this)) {
|
||||
// Change scene manager?
|
||||
if (SceneManager != child->SceneManager)
|
||||
child->setSceneManager(SceneManager);
|
||||
@ -273,7 +257,6 @@ namespace scene
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! Removes a child from this scene node.
|
||||
/**
|
||||
\param child A pointer to the child which shall be removed.
|
||||
@ -294,7 +277,6 @@ namespace scene
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//! Removes all children of this scene node
|
||||
/** The scene nodes found in the children list are also dropped
|
||||
and might be deleted if no other grab exists on them.
|
||||
@ -309,7 +291,6 @@ namespace scene
|
||||
Children.clear();
|
||||
}
|
||||
|
||||
|
||||
//! Removes this scene node from the scene
|
||||
/** If no other grab exists for this node, it will be deleted.
|
||||
*/
|
||||
@ -319,7 +300,6 @@ namespace scene
|
||||
Parent->removeChild(this);
|
||||
}
|
||||
|
||||
|
||||
//! Returns the material based on the zero based index i.
|
||||
/** To get the amount of materials used by this scene node, use
|
||||
getMaterialCount(). This function is needed for inserting the
|
||||
@ -333,7 +313,6 @@ namespace scene
|
||||
return video::IdentityMaterial;
|
||||
}
|
||||
|
||||
|
||||
//! Get amount of materials used by this scene node.
|
||||
/** \return Current amount of materials of this scene node. */
|
||||
virtual u32 getMaterialCount() const
|
||||
@ -341,18 +320,17 @@ namespace scene
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
//! Execute a function on all materials of this scene node.
|
||||
/** Useful for setting material properties, e.g. if you want the whole
|
||||
mesh to be affected by light. */
|
||||
template <typename F>
|
||||
void forEachMaterial(F &&fn) {
|
||||
void forEachMaterial(F &&fn)
|
||||
{
|
||||
for (u32 i = 0; i < getMaterialCount(); i++) {
|
||||
fn(getMaterial(i));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! Gets the scale of the scene node relative to its parent.
|
||||
/** This is the scale of this node relative to its parent.
|
||||
If you want the absolute scale, use
|
||||
@ -363,7 +341,6 @@ namespace scene
|
||||
return RelativeScale;
|
||||
}
|
||||
|
||||
|
||||
//! Sets the relative scale of the scene node.
|
||||
/** \param scale New scale of the node, relative to its parent. */
|
||||
virtual void setScale(const core::vector3df &scale)
|
||||
@ -371,7 +348,6 @@ namespace scene
|
||||
RelativeScale = scale;
|
||||
}
|
||||
|
||||
|
||||
//! Gets the rotation of the node relative to its parent.
|
||||
/** Note that this is the relative rotation of the node.
|
||||
If you want the absolute rotation, use
|
||||
@ -382,7 +358,6 @@ namespace scene
|
||||
return RelativeRotation;
|
||||
}
|
||||
|
||||
|
||||
//! Sets the rotation of the node relative to its parent.
|
||||
/** This only modifies the relative rotation of the node.
|
||||
\param rotation New rotation of the node in degrees. */
|
||||
@ -391,7 +366,6 @@ namespace scene
|
||||
RelativeRotation = rotation;
|
||||
}
|
||||
|
||||
|
||||
//! Gets the position of the node relative to its parent.
|
||||
/** Note that the position is relative to the parent. If you want
|
||||
the position in world coordinates, use getAbsolutePosition() instead.
|
||||
@ -401,7 +375,6 @@ namespace scene
|
||||
return RelativeTranslation;
|
||||
}
|
||||
|
||||
|
||||
//! Sets the position of the node relative to its parent.
|
||||
/** Note that the position is relative to the parent.
|
||||
\param newpos New relative position of the scene node. */
|
||||
@ -410,7 +383,6 @@ namespace scene
|
||||
RelativeTranslation = newpos;
|
||||
}
|
||||
|
||||
|
||||
//! Gets the absolute position of the node in world coordinates.
|
||||
/** If you want the position of the node relative to its parent,
|
||||
use getPosition() instead.
|
||||
@ -425,7 +397,6 @@ namespace scene
|
||||
return AbsoluteTransformation.getTranslation();
|
||||
}
|
||||
|
||||
|
||||
//! Set a culling style or disable culling completely.
|
||||
/** Box cullling (EAC_BOX) is set by default. Note that not
|
||||
all SceneNodes support culling and that some nodes always cull
|
||||
@ -437,7 +408,6 @@ namespace scene
|
||||
AutomaticCullingState = state;
|
||||
}
|
||||
|
||||
|
||||
//! Gets the automatic culling state.
|
||||
/** \return The automatic culling state. */
|
||||
u32 getAutomaticCulling() const
|
||||
@ -445,7 +415,6 @@ namespace scene
|
||||
return AutomaticCullingState;
|
||||
}
|
||||
|
||||
|
||||
//! Sets if debug data like bounding boxes should be drawn.
|
||||
/** A bitwise OR of the types from @ref irr::scene::E_DEBUG_SCENE_TYPE.
|
||||
Please note that not all scene nodes support all debug data types.
|
||||
@ -463,7 +432,6 @@ namespace scene
|
||||
return DebugDataVisible;
|
||||
}
|
||||
|
||||
|
||||
//! Sets if this scene node is a debug object.
|
||||
/** Debug objects have some special properties, for example they can be easily
|
||||
excluded from collision detection or from serialization, etc. */
|
||||
@ -472,7 +440,6 @@ namespace scene
|
||||
IsDebugObject = debugObject;
|
||||
}
|
||||
|
||||
|
||||
//! Returns if this scene node is a debug object.
|
||||
/** Debug objects have some special properties, for example they can be easily
|
||||
excluded from collision detection or from serialization, etc.
|
||||
@ -482,7 +449,6 @@ namespace scene
|
||||
return IsDebugObject;
|
||||
}
|
||||
|
||||
|
||||
//! Returns a const reference to the list of all children.
|
||||
/** \return The list of all children of this node. */
|
||||
const std::list<ISceneNode *> &getChildren() const
|
||||
@ -490,7 +456,6 @@ namespace scene
|
||||
return Children;
|
||||
}
|
||||
|
||||
|
||||
//! Changes the parent of the scene node.
|
||||
/** \param newParent The new parent to be used. */
|
||||
virtual void setParent(ISceneNode *newParent)
|
||||
@ -504,22 +469,18 @@ namespace scene
|
||||
drop();
|
||||
}
|
||||
|
||||
|
||||
//! Updates the absolute position based on the relative and the parents position
|
||||
/** Note: This does not recursively update the parents absolute positions, so if you have a deeper
|
||||
hierarchy you might want to update the parents first.*/
|
||||
virtual void updateAbsolutePosition()
|
||||
{
|
||||
if (Parent)
|
||||
{
|
||||
if (Parent) {
|
||||
AbsoluteTransformation =
|
||||
Parent->getAbsoluteTransformation() * getRelativeTransformation();
|
||||
}
|
||||
else
|
||||
} else
|
||||
AbsoluteTransformation = getRelativeTransformation();
|
||||
}
|
||||
|
||||
|
||||
//! Returns the parent of this scene node
|
||||
/** \return A pointer to the parent. */
|
||||
scene::ISceneNode *getParent() const
|
||||
@ -527,7 +488,6 @@ namespace scene
|
||||
return Parent;
|
||||
}
|
||||
|
||||
|
||||
//! Returns type of the scene node
|
||||
/** \return The type of this node. */
|
||||
virtual ESCENE_NODE_TYPE getType() const
|
||||
@ -549,7 +509,6 @@ namespace scene
|
||||
virtual ISceneManager *getSceneManager(void) const { return SceneManager; }
|
||||
|
||||
protected:
|
||||
|
||||
//! A clone function for the ISceneNode members.
|
||||
/** This method can be used by clone() implementations of
|
||||
derived classes
|
||||
@ -634,6 +593,5 @@ namespace scene
|
||||
bool IsDebugObject;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -20,7 +20,6 @@ OnSetConstants method will be called every frame now. */
|
||||
class IShaderConstantSetCallBack : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Called to let the callBack know the used material (optional method)
|
||||
/**
|
||||
\code
|
||||
@ -76,6 +75,5 @@ public:
|
||||
virtual void OnSetConstants(IMaterialRendererServices *services, s32 userData) = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
@ -28,12 +28,10 @@ namespace scene
|
||||
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;
|
||||
@ -106,7 +104,6 @@ namespace scene
|
||||
core::vector3df StaticNormal;
|
||||
};
|
||||
|
||||
|
||||
//! Animation keyframe which describes a new position
|
||||
struct SPositionKey
|
||||
{
|
||||
@ -131,7 +128,8 @@ namespace scene
|
||||
//! Joints
|
||||
struct SJoint
|
||||
{
|
||||
SJoint() : UseAnimationFrom(0), GlobalSkinningSpace(false),
|
||||
SJoint() :
|
||||
UseAnimationFrom(0), GlobalSkinningSpace(false),
|
||||
positionHint(-1), scaleHint(-1), rotationHint(-1)
|
||||
{
|
||||
}
|
||||
@ -182,7 +180,6 @@ namespace scene
|
||||
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
|
||||
|
@ -16,7 +16,6 @@ namespace irr
|
||||
namespace video
|
||||
{
|
||||
|
||||
|
||||
//! Enumeration flags used to tell the video driver with setTextureCreationFlag in which format textures should be created.
|
||||
enum E_TEXTURE_CREATION_FLAG
|
||||
{
|
||||
@ -176,9 +175,9 @@ and write a warning or an error message to the output buffer.
|
||||
class ITexture : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! constructor
|
||||
ITexture(const io::path& name, E_TEXTURE_TYPE type) : NamedPath(name), DriverType(EDT_NULL), OriginalColorFormat(ECF_UNKNOWN),
|
||||
ITexture(const io::path &name, E_TEXTURE_TYPE type) :
|
||||
NamedPath(name), DriverType(EDT_NULL), OriginalColorFormat(ECF_UNKNOWN),
|
||||
ColorFormat(ECF_UNKNOWN), Pitch(0), HasMipMaps(false), IsRenderTarget(false), Source(ETS_UNKNOWN), Type(type)
|
||||
{
|
||||
}
|
||||
@ -287,8 +286,7 @@ public:
|
||||
{
|
||||
bool status = false;
|
||||
|
||||
switch (ColorFormat)
|
||||
{
|
||||
switch (ColorFormat) {
|
||||
case ECF_A8R8G8B8:
|
||||
case ECF_A1R5G5B5:
|
||||
case ECF_A16B16G16R16F:
|
||||
@ -306,7 +304,6 @@ public:
|
||||
E_TEXTURE_TYPE getType() const { return Type; }
|
||||
|
||||
protected:
|
||||
|
||||
//! Helper function, helps to get the desired texture creation format from the flags.
|
||||
/** \return Either ETCF_ALWAYS_32_BIT, ETCF_ALWAYS_16_BIT,
|
||||
ETCF_OPTIMIZED_FOR_QUALITY, or ETCF_OPTIMIZED_FOR_SPEED. */
|
||||
@ -336,6 +333,5 @@ protected:
|
||||
E_TEXTURE_TYPE Type;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
@ -44,6 +44,5 @@ namespace scene
|
||||
virtual u32 getChangedID() const = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -112,8 +112,7 @@ namespace video
|
||||
"FogExp",
|
||||
"FogLinear",
|
||||
"FogExp2",
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
//! Interface to driver which is able to perform 2d and 3d graphics functions.
|
||||
/** This interface is one of the most important interfaces of
|
||||
@ -126,7 +125,6 @@ namespace video
|
||||
class IVideoDriver : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Applications must call this method before performing any rendering.
|
||||
/** This method can clear the back- and the z-buffer.
|
||||
\param clearFlag A combination of the E_CLEAR_BUFFER_FLAG bit-flags.
|
||||
@ -1207,5 +1205,3 @@ namespace video
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
||||
|
||||
|
@ -20,19 +20,23 @@ namespace irr
|
||||
class ILogger;
|
||||
class IEventReceiver;
|
||||
|
||||
namespace io {
|
||||
namespace io
|
||||
{
|
||||
class IFileSystem;
|
||||
} // end namespace io
|
||||
|
||||
namespace gui {
|
||||
namespace gui
|
||||
{
|
||||
class IGUIEnvironment;
|
||||
} // end namespace gui
|
||||
|
||||
namespace scene {
|
||||
namespace scene
|
||||
{
|
||||
class ISceneManager;
|
||||
} // end namespace scene
|
||||
|
||||
namespace video {
|
||||
namespace video
|
||||
{
|
||||
class IContextManager;
|
||||
extern "C" IRRLICHT_API bool IRRCALLCONV isDriverSupported(E_DRIVER_TYPE driver);
|
||||
} // end namespace video
|
||||
@ -46,7 +50,6 @@ namespace irr
|
||||
class IrrlichtDevice : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
|
||||
//! Runs the device.
|
||||
/** Also increments the virtual timer by calling
|
||||
ITimer::tick();. You can prevent this
|
||||
|
@ -183,5 +183,3 @@ namespace irr
|
||||
};
|
||||
|
||||
} // end namespace irr
|
||||
|
||||
|
||||
|
@ -36,23 +36,24 @@ const char* const sBuiltInVertexTypeNames[] =
|
||||
"standard",
|
||||
"2tcoords",
|
||||
"tangents",
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
//! standard vertex used by the Irrlicht engine.
|
||||
struct S3DVertex
|
||||
{
|
||||
//! default constructor
|
||||
constexpr S3DVertex() : Color(0xffffffff) {}
|
||||
constexpr S3DVertex() :
|
||||
Color(0xffffffff) {}
|
||||
|
||||
//! constructor
|
||||
constexpr S3DVertex(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv)
|
||||
: Pos(x,y,z), Normal(nx,ny,nz), Color(c), TCoords(tu,tv) {}
|
||||
constexpr S3DVertex(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz, SColor c, f32 tu, f32 tv) :
|
||||
Pos(x, y, z), Normal(nx, ny, nz), Color(c), TCoords(tu, tv) {}
|
||||
|
||||
//! constructor
|
||||
constexpr S3DVertex(const core::vector3df &pos, const core::vector3df &normal,
|
||||
SColor color, const core::vector2df& tcoords)
|
||||
: Pos(pos), Normal(normal), Color(color), TCoords(tcoords) {}
|
||||
SColor color, const core::vector2df &tcoords) :
|
||||
Pos(pos),
|
||||
Normal(normal), Color(color), TCoords(tcoords) {}
|
||||
|
||||
//! Position
|
||||
core::vector3df Pos;
|
||||
@ -103,7 +104,6 @@ struct S3DVertex
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//! Vertex with two texture coordinates.
|
||||
/** Usually used for geometry with lightmaps
|
||||
or other special materials.
|
||||
@ -111,39 +111,46 @@ or other special materials.
|
||||
struct S3DVertex2TCoords : public S3DVertex
|
||||
{
|
||||
//! default constructor
|
||||
constexpr S3DVertex2TCoords() : S3DVertex() {}
|
||||
constexpr S3DVertex2TCoords() :
|
||||
S3DVertex() {}
|
||||
|
||||
//! constructor with two different texture coords, but no normal
|
||||
constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2)
|
||||
: S3DVertex(x,y,z, 0.0f, 0.0f, 0.0f, c, tu,tv), TCoords2(tu2,tv2) {}
|
||||
constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2) :
|
||||
S3DVertex(x, y, z, 0.0f, 0.0f, 0.0f, c, tu, tv), TCoords2(tu2, tv2) {}
|
||||
|
||||
//! constructor with two different texture coords, but no normal
|
||||
constexpr S3DVertex2TCoords(const core::vector3df &pos, SColor color,
|
||||
const core::vector2df& tcoords, const core::vector2df& tcoords2)
|
||||
: S3DVertex(pos, core::vector3df(), color, tcoords), TCoords2(tcoords2) {}
|
||||
const core::vector2df &tcoords, const core::vector2df &tcoords2) :
|
||||
S3DVertex(pos, core::vector3df(), color, tcoords),
|
||||
TCoords2(tcoords2) {}
|
||||
|
||||
//! constructor with all values
|
||||
constexpr S3DVertex2TCoords(const core::vector3df &pos, const core::vector3df &normal, const SColor &color,
|
||||
const core::vector2df& tcoords, const core::vector2df& tcoords2)
|
||||
: S3DVertex(pos, normal, color, tcoords), TCoords2(tcoords2) {}
|
||||
const core::vector2df &tcoords, const core::vector2df &tcoords2) :
|
||||
S3DVertex(pos, normal, color, tcoords),
|
||||
TCoords2(tcoords2) {}
|
||||
|
||||
//! constructor with all values
|
||||
constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz,
|
||||
SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2)
|
||||
: S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), TCoords2(tu2,tv2) {}
|
||||
SColor c, f32 tu, f32 tv, f32 tu2, f32 tv2) :
|
||||
S3DVertex(x, y, z, nx, ny, nz, c, tu, tv),
|
||||
TCoords2(tu2, tv2) {}
|
||||
|
||||
//! constructor with the same texture coords and normal
|
||||
constexpr S3DVertex2TCoords(f32 x, f32 y, f32 z, f32 nx, f32 ny, f32 nz,
|
||||
SColor c, f32 tu, f32 tv)
|
||||
: S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), TCoords2(tu,tv) {}
|
||||
SColor c, f32 tu, f32 tv) :
|
||||
S3DVertex(x, y, z, nx, ny, nz, c, tu, tv),
|
||||
TCoords2(tu, tv) {}
|
||||
|
||||
//! constructor with the same texture coords and normal
|
||||
constexpr S3DVertex2TCoords(const core::vector3df &pos, const core::vector3df &normal,
|
||||
SColor color, const core::vector2df& tcoords)
|
||||
: S3DVertex(pos, normal, color, tcoords), TCoords2(tcoords) {}
|
||||
SColor color, const core::vector2df &tcoords) :
|
||||
S3DVertex(pos, normal, color, tcoords),
|
||||
TCoords2(tcoords) {}
|
||||
|
||||
//! constructor from S3DVertex
|
||||
constexpr S3DVertex2TCoords(const S3DVertex& o) : S3DVertex(o) {}
|
||||
constexpr S3DVertex2TCoords(const S3DVertex &o) :
|
||||
S3DVertex(o) {}
|
||||
|
||||
//! Second set of texture coordinates
|
||||
core::vector2df TCoords2;
|
||||
@ -185,7 +192,6 @@ struct S3DVertex2TCoords : public S3DVertex
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//! Vertex with a tangent and binormal vector.
|
||||
/** Usually used for tangent space normal mapping.
|
||||
Usually tangent and binormal get send to shaders as texture coordinate sets 1 and 2.
|
||||
@ -193,30 +199,34 @@ struct S3DVertex2TCoords : public S3DVertex
|
||||
struct S3DVertexTangents : public S3DVertex
|
||||
{
|
||||
//! default constructor
|
||||
S3DVertexTangents() : S3DVertex() { }
|
||||
S3DVertexTangents() :
|
||||
S3DVertex() {}
|
||||
|
||||
//! constructor
|
||||
constexpr S3DVertexTangents(f32 x, f32 y, f32 z, f32 nx = 0.0f, f32 ny = 0.0f, f32 nz = 0.0f,
|
||||
SColor c = 0xFFFFFFFF, f32 tu = 0.0f, f32 tv = 0.0f,
|
||||
f32 tanx = 0.0f, f32 tany = 0.0f, f32 tanz = 0.0f,
|
||||
f32 bx=0.0f, f32 by=0.0f, f32 bz=0.0f)
|
||||
: S3DVertex(x,y,z, nx,ny,nz, c, tu,tv), Tangent(tanx,tany,tanz), Binormal(bx,by,bz) { }
|
||||
f32 bx = 0.0f, f32 by = 0.0f, f32 bz = 0.0f) :
|
||||
S3DVertex(x, y, z, nx, ny, nz, c, tu, tv),
|
||||
Tangent(tanx, tany, tanz), Binormal(bx, by, bz) {}
|
||||
|
||||
//! constructor
|
||||
constexpr S3DVertexTangents(const core::vector3df &pos, SColor c,
|
||||
const core::vector2df& tcoords)
|
||||
: S3DVertex(pos, core::vector3df(), c, tcoords) { }
|
||||
const core::vector2df &tcoords) :
|
||||
S3DVertex(pos, core::vector3df(), c, tcoords) {}
|
||||
|
||||
//! constructor
|
||||
constexpr S3DVertexTangents(const core::vector3df &pos,
|
||||
const core::vector3df &normal, SColor c,
|
||||
const core::vector2df &tcoords,
|
||||
const core::vector3df &tangent = core::vector3df(),
|
||||
const core::vector3df& binormal=core::vector3df())
|
||||
: S3DVertex(pos, normal, c, tcoords), Tangent(tangent), Binormal(binormal) { }
|
||||
const core::vector3df &binormal = core::vector3df()) :
|
||||
S3DVertex(pos, normal, c, tcoords),
|
||||
Tangent(tangent), Binormal(binormal) {}
|
||||
|
||||
//! constructor from S3DVertex
|
||||
constexpr S3DVertexTangents(const S3DVertex& o) : S3DVertex(o) {}
|
||||
constexpr S3DVertexTangents(const S3DVertex &o) :
|
||||
S3DVertex(o) {}
|
||||
|
||||
//! Tangent vector along the x-axis of the texture
|
||||
core::vector3df Tangent;
|
||||
@ -262,12 +272,9 @@ struct S3DVertexTangents : public S3DVertex
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
inline u32 getVertexPitchFromType(E_VERTEX_TYPE vertexType)
|
||||
{
|
||||
switch (vertexType)
|
||||
{
|
||||
switch (vertexType) {
|
||||
case video::EVT_2TCOORDS:
|
||||
return sizeof(video::S3DVertex2TCoords);
|
||||
case video::EVT_TANGENTS:
|
||||
@ -277,6 +284,5 @@ inline u32 getVertexPitchFromType(E_VERTEX_TYPE vertexType)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
@ -18,7 +18,8 @@ namespace scene
|
||||
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)
|
||||
SAnimatedMesh(scene::IMesh *mesh = 0, scene::E_ANIMATED_MESH_TYPE type = scene::EAMT_UNKNOWN) :
|
||||
IAnimatedMesh(), FramesPerSecond(25.f), Type(type)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
setDebugName("SAnimatedMesh");
|
||||
@ -76,8 +77,7 @@ namespace scene
|
||||
//! adds a Mesh
|
||||
void addMesh(IMesh *mesh)
|
||||
{
|
||||
if (mesh)
|
||||
{
|
||||
if (mesh) {
|
||||
mesh->grab();
|
||||
Meshes.push_back(mesh);
|
||||
}
|
||||
@ -173,6 +173,5 @@ namespace scene
|
||||
E_ANIMATED_MESH_TYPE Type;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
150
include/SColor.h
150
include/SColor.h
@ -108,9 +108,7 @@ namespace video
|
||||
"D32",
|
||||
"D24S8",
|
||||
"UNKNOWN",
|
||||
0
|
||||
};
|
||||
|
||||
0};
|
||||
|
||||
//! Creates a 16 bit A1R5G5B5 color
|
||||
inline u16 RGBA16(u32 r, u32 g, u32 b, u32 a = 0xFF)
|
||||
@ -121,14 +119,12 @@ namespace video
|
||||
(b & 0xF8) >> 3);
|
||||
}
|
||||
|
||||
|
||||
//! Creates a 16 bit A1R5G5B5 color
|
||||
inline u16 RGB16(u32 r, u32 g, u32 b)
|
||||
{
|
||||
return RGBA16(r, g, b);
|
||||
}
|
||||
|
||||
|
||||
//! Creates a 16bit A1R5G5B5 color, based on 16bit input values
|
||||
inline u16 RGB16from16(u16 r, u16 g, u16 b)
|
||||
{
|
||||
@ -138,7 +134,6 @@ namespace video
|
||||
(b & 0x1F));
|
||||
}
|
||||
|
||||
|
||||
//! Converts a 32bit (X8R8G8B8) color to a 16bit A1R5G5B5 color
|
||||
inline u16 X8R8G8B8toA1R5G5B5(u32 color)
|
||||
{
|
||||
@ -148,7 +143,6 @@ namespace video
|
||||
(color & 0x000000F8) >> 3);
|
||||
}
|
||||
|
||||
|
||||
//! Converts a 32bit (A8R8G8B8) color to a 16bit A1R5G5B5 color
|
||||
inline u16 A8R8G8B8toA1R5G5B5(u32 color)
|
||||
{
|
||||
@ -158,7 +152,6 @@ namespace video
|
||||
(color & 0x000000F8) >> 3);
|
||||
}
|
||||
|
||||
|
||||
//! Converts a 32bit (A8R8G8B8) color to a 16bit R5G6B5 color
|
||||
inline u16 A8R8G8B8toR5G6B5(u32 color)
|
||||
{
|
||||
@ -167,7 +160,6 @@ namespace video
|
||||
(color & 0x000000F8) >> 3);
|
||||
}
|
||||
|
||||
|
||||
//! Convert A8R8G8B8 Color from A1R5G5B5 color
|
||||
/** build a nicer 32bit Color by extending dest lower bits with source high bits. */
|
||||
inline u32 A1R5G5B5toA8R8G8B8(u16 color)
|
||||
@ -175,11 +167,9 @@ namespace video
|
||||
return (((-((s32)color & 0x00008000) >> (s32)31) & 0xFF000000) |
|
||||
((color & 0x00007C00) << 9) | ((color & 0x00007000) << 4) |
|
||||
((color & 0x000003E0) << 6) | ((color & 0x00000380) << 1) |
|
||||
(( color & 0x0000001F ) << 3) | (( color & 0x0000001C ) >> 2)
|
||||
);
|
||||
((color & 0x0000001F) << 3) | ((color & 0x0000001C) >> 2));
|
||||
}
|
||||
|
||||
|
||||
//! Returns A8R8G8B8 Color from R5G6B5 color
|
||||
inline u32 R5G6B5toA8R8G8B8(u16 color)
|
||||
{
|
||||
@ -189,22 +179,18 @@ namespace video
|
||||
((color & 0x001F) << 3);
|
||||
}
|
||||
|
||||
|
||||
//! Returns A1R5G5B5 Color from R5G6B5 color
|
||||
inline u16 R5G6B5toA1R5G5B5(u16 color)
|
||||
{
|
||||
return 0x8000 | (((color & 0xFFC0) >> 1) | (color & 0x1F));
|
||||
}
|
||||
|
||||
|
||||
//! Returns R5G6B5 Color from A1R5G5B5 color
|
||||
inline u16 A1R5G5B5toR5G6B5(u16 color)
|
||||
{
|
||||
return (((color & 0x7FE0) << 1) | (color & 0x1F));
|
||||
}
|
||||
|
||||
|
||||
|
||||
//! Returns the alpha component from A1R5G5B5 color
|
||||
/** In Irrlicht, alpha refers to opacity.
|
||||
\return The alpha value of the color. 0 is transparent, 1 is opaque. */
|
||||
@ -213,7 +199,6 @@ namespace video
|
||||
return ((color >> 15) & 0x1);
|
||||
}
|
||||
|
||||
|
||||
//! Returns the red component from A1R5G5B5 color.
|
||||
/** Shift left by 3 to get 8 bit value. */
|
||||
inline u32 getRed(u16 color)
|
||||
@ -221,7 +206,6 @@ namespace video
|
||||
return ((color >> 10) & 0x1F);
|
||||
}
|
||||
|
||||
|
||||
//! Returns the green component from A1R5G5B5 color
|
||||
/** Shift left by 3 to get 8 bit value. */
|
||||
inline u32 getGreen(u16 color)
|
||||
@ -229,7 +213,6 @@ namespace video
|
||||
return ((color >> 5) & 0x1F);
|
||||
}
|
||||
|
||||
|
||||
//! Returns the blue component from A1R5G5B5 color
|
||||
/** Shift left by 3 to get 8 bit value. */
|
||||
inline u32 getBlue(u16 color)
|
||||
@ -237,14 +220,12 @@ namespace video
|
||||
return (color & 0x1F);
|
||||
}
|
||||
|
||||
|
||||
//! Returns the average from a 16 bit A1R5G5B5 color
|
||||
inline s32 getAverage(s16 color)
|
||||
{
|
||||
return ((getRed(color) << 3) + (getGreen(color) << 3) + (getBlue(color) << 3)) / 3;
|
||||
}
|
||||
|
||||
|
||||
//! Class representing a 32 bit ARGB color.
|
||||
/** The color values for alpha, red, green, and blue are
|
||||
stored in a single u32. So all four values may be between 0 and 255.
|
||||
@ -257,19 +238,18 @@ namespace video
|
||||
class SColor
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor of the Color. Does nothing.
|
||||
/** The color value is not initialized to save time. */
|
||||
SColor() {}
|
||||
|
||||
//! Constructs the color from 4 values representing the alpha, red, green and blue component.
|
||||
/** Must be values between 0 and 255. */
|
||||
constexpr SColor (u32 a, u32 r, u32 g, u32 b)
|
||||
: color(((a & 0xff)<<24) | ((r & 0xff)<<16) | ((g & 0xff)<<8) | (b & 0xff)) {}
|
||||
constexpr SColor(u32 a, u32 r, u32 g, u32 b) :
|
||||
color(((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff)) {}
|
||||
|
||||
//! Constructs the color from a 32 bit value. Could be another color.
|
||||
constexpr SColor(u32 clr)
|
||||
: color(clr) {}
|
||||
constexpr SColor(u32 clr) :
|
||||
color(clr) {}
|
||||
|
||||
//! Returns the alpha component of the color.
|
||||
/** The alpha component defines how opaque a color is.
|
||||
@ -418,13 +398,17 @@ namespace video
|
||||
|
||||
return SColor(
|
||||
core::clamp(core::floor32(
|
||||
getAlpha() * mul0 + c1.getAlpha() * mul1 + c2.getAlpha() * mul2 ), 0, 255 ),
|
||||
getAlpha() * mul0 + c1.getAlpha() * mul1 + c2.getAlpha() * mul2),
|
||||
0, 255),
|
||||
core::clamp(core::floor32(
|
||||
getRed() * mul0 + c1.getRed() * mul1 + c2.getRed() * mul2 ), 0, 255 ),
|
||||
getRed() * mul0 + c1.getRed() * mul1 + c2.getRed() * mul2),
|
||||
0, 255),
|
||||
core::clamp(core::floor32(
|
||||
getGreen() * mul0 + c1.getGreen() * mul1 + c2.getGreen() * mul2 ), 0, 255 ),
|
||||
getGreen() * mul0 + c1.getGreen() * mul1 + c2.getGreen() * mul2),
|
||||
0, 255),
|
||||
core::clamp(core::floor32(
|
||||
getBlue() * mul0 + c1.getBlue() * mul1 + c2.getBlue() * mul2 ), 0, 255 ));
|
||||
getBlue() * mul0 + c1.getBlue() * mul1 + c2.getBlue() * mul2),
|
||||
0, 255));
|
||||
}
|
||||
|
||||
//! set the color by expecting data in the given format
|
||||
@ -433,8 +417,7 @@ namespace video
|
||||
*/
|
||||
void setData(const void *data, ECOLOR_FORMAT format)
|
||||
{
|
||||
switch (format)
|
||||
{
|
||||
switch (format) {
|
||||
case ECF_A1R5G5B5:
|
||||
color = A1R5G5B5toA8R8G8B8(*(u16 *)data);
|
||||
break;
|
||||
@ -444,12 +427,10 @@ namespace video
|
||||
case ECF_A8R8G8B8:
|
||||
color = *(u32 *)data;
|
||||
break;
|
||||
case ECF_R8G8B8:
|
||||
{
|
||||
case ECF_R8G8B8: {
|
||||
const u8 *p = (u8 *)data;
|
||||
set(255, p[0], p[1], p[2]);
|
||||
}
|
||||
break;
|
||||
} break;
|
||||
default:
|
||||
color = 0xffffffff;
|
||||
break;
|
||||
@ -462,37 +443,28 @@ namespace video
|
||||
*/
|
||||
void getData(void *data, ECOLOR_FORMAT format) const
|
||||
{
|
||||
switch(format)
|
||||
{
|
||||
case ECF_A1R5G5B5:
|
||||
{
|
||||
switch (format) {
|
||||
case ECF_A1R5G5B5: {
|
||||
u16 *dest = (u16 *)data;
|
||||
*dest = video::A8R8G8B8toA1R5G5B5(color);
|
||||
}
|
||||
break;
|
||||
} break;
|
||||
|
||||
case ECF_R5G6B5:
|
||||
{
|
||||
case ECF_R5G6B5: {
|
||||
u16 *dest = (u16 *)data;
|
||||
*dest = video::A8R8G8B8toR5G6B5(color);
|
||||
}
|
||||
break;
|
||||
} break;
|
||||
|
||||
case ECF_R8G8B8:
|
||||
{
|
||||
case ECF_R8G8B8: {
|
||||
u8 *dest = (u8 *)data;
|
||||
dest[0] = (u8)getRed();
|
||||
dest[1] = (u8)getGreen();
|
||||
dest[2] = (u8)getBlue();
|
||||
}
|
||||
break;
|
||||
} break;
|
||||
|
||||
case ECF_A8R8G8B8:
|
||||
{
|
||||
case ECF_A8R8G8B8: {
|
||||
u32 *dest = (u32 *)data;
|
||||
*dest = color;
|
||||
}
|
||||
break;
|
||||
} break;
|
||||
|
||||
default:
|
||||
break;
|
||||
@ -503,7 +475,6 @@ namespace video
|
||||
u32 color;
|
||||
};
|
||||
|
||||
|
||||
//! Class representing a color with four floats.
|
||||
/** The color values for red, green, blue
|
||||
and alpha are each stored in a 32 bit floating point variable.
|
||||
@ -516,7 +487,8 @@ namespace video
|
||||
public:
|
||||
//! Default constructor for SColorf.
|
||||
/** Sets red, green and blue to 0.0f and alpha to 1.0f. */
|
||||
SColorf() : r(0.0f), g(0.0f), b(0.0f), a(1.0f) {}
|
||||
SColorf() :
|
||||
r(0.0f), g(0.0f), b(0.0f), a(1.0f) {}
|
||||
|
||||
//! Constructs a color from up to four color values: red, green, blue, and alpha.
|
||||
/** \param r: Red color component. Should be a value between
|
||||
@ -529,7 +501,8 @@ namespace video
|
||||
component defines how transparent a color should be. Has to be
|
||||
a value between 0.0f and 1.0f, 1.0f means not transparent
|
||||
(opaque), 0.0f means fully transparent. */
|
||||
SColorf(f32 r, f32 g, f32 b, f32 a = 1.0f) : r(r), g(g), b(b), a(a) {}
|
||||
SColorf(f32 r, f32 g, f32 b, f32 a = 1.0f) :
|
||||
r(r), g(g), b(b), a(a) {}
|
||||
|
||||
//! Constructs a color from 32 bit Color.
|
||||
/** \param c: 32 bit color from which this SColorf class is
|
||||
@ -556,7 +529,12 @@ namespace video
|
||||
no green (=black) and 1.0f, meaning full green.
|
||||
\param bb: Blue color component. Should be a value between 0.0f meaning
|
||||
no blue (=black) and 1.0f, meaning full blue. */
|
||||
void set(f32 rr, f32 gg, f32 bb) {r = rr; g =gg; b = bb; }
|
||||
void set(f32 rr, f32 gg, f32 bb)
|
||||
{
|
||||
r = rr;
|
||||
g = gg;
|
||||
b = bb;
|
||||
}
|
||||
|
||||
//! Sets all four color components to new values at once.
|
||||
/** \param aa: Alpha component. Should be a value between 0.0f meaning
|
||||
@ -567,7 +545,13 @@ namespace video
|
||||
no green and 1.0f, meaning full green.
|
||||
\param bb: Blue color component. Should be a value between 0.0f meaning
|
||||
no blue and 1.0f, meaning full blue. */
|
||||
void set(f32 aa, f32 rr, f32 gg, f32 bb) {a = aa; r = rr; g =gg; b = bb; }
|
||||
void set(f32 aa, f32 rr, f32 gg, f32 bb)
|
||||
{
|
||||
a = aa;
|
||||
r = rr;
|
||||
g = gg;
|
||||
b = bb;
|
||||
}
|
||||
|
||||
//! Interpolates the color with a f32 value to another color
|
||||
/** \param other: Other color
|
||||
@ -601,16 +585,22 @@ namespace video
|
||||
a * mul0 + c1.a * mul1 + c2.a * mul2);
|
||||
}
|
||||
|
||||
|
||||
//! Sets a color component by index. R=0, G=1, B=2, A=3
|
||||
void setColorComponentValue(s32 index, f32 value)
|
||||
{
|
||||
switch(index)
|
||||
{
|
||||
case 0: r = value; break;
|
||||
case 1: g = value; break;
|
||||
case 2: b = value; break;
|
||||
case 3: a = value; break;
|
||||
switch (index) {
|
||||
case 0:
|
||||
r = value;
|
||||
break;
|
||||
case 1:
|
||||
g = value;
|
||||
break;
|
||||
case 2:
|
||||
b = value;
|
||||
break;
|
||||
case 3:
|
||||
a = value;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -639,7 +629,6 @@ namespace video
|
||||
f32 a;
|
||||
};
|
||||
|
||||
|
||||
//! Class representing a color in HSL format
|
||||
/** The color values for hue, saturation, luminance
|
||||
are stored in 32bit floating point variables. Hue is in range [0,360],
|
||||
@ -648,8 +637,8 @@ namespace video
|
||||
class SColorHSL
|
||||
{
|
||||
public:
|
||||
constexpr SColorHSL ( f32 h = 0.f, f32 s = 0.f, f32 l = 0.f )
|
||||
: Hue ( h ), Saturation ( s ), Luminance ( l ) {}
|
||||
constexpr SColorHSL(f32 h = 0.f, f32 s = 0.f, f32 l = 0.f) :
|
||||
Hue(h), Saturation(s), Luminance(l) {}
|
||||
|
||||
void fromRGB(const SColorf &color);
|
||||
void toRGB(SColorf &color) const;
|
||||
@ -660,7 +649,6 @@ namespace video
|
||||
|
||||
private:
|
||||
inline f32 toRGB1(f32 rm1, f32 rm2, f32 rh) const;
|
||||
|
||||
};
|
||||
|
||||
inline void SColorHSL::fromRGB(const SColorf &color)
|
||||
@ -668,20 +656,16 @@ namespace video
|
||||
const f32 maxVal = core::max_(color.getRed(), color.getGreen(), color.getBlue());
|
||||
const f32 minVal = (f32)core::min_(color.getRed(), color.getGreen(), color.getBlue());
|
||||
Luminance = (maxVal + minVal) * 50;
|
||||
if (core::equals(maxVal, minVal))
|
||||
{
|
||||
if (core::equals(maxVal, minVal)) {
|
||||
Hue = 0.f;
|
||||
Saturation = 0.f;
|
||||
return;
|
||||
}
|
||||
|
||||
const f32 delta = maxVal - minVal;
|
||||
if ( Luminance <= 50 )
|
||||
{
|
||||
if (Luminance <= 50) {
|
||||
Saturation = (delta) / (maxVal + minVal);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
Saturation = (delta) / (2 - maxVal - minVal);
|
||||
}
|
||||
Saturation *= 100;
|
||||
@ -698,7 +682,6 @@ namespace video
|
||||
Hue += 360;
|
||||
}
|
||||
|
||||
|
||||
inline void SColorHSL::toRGB(SColorf &color) const
|
||||
{
|
||||
const f32 l = Luminance / 100;
|
||||
@ -710,12 +693,9 @@ namespace video
|
||||
|
||||
f32 rm2;
|
||||
|
||||
if ( Luminance <= 50 )
|
||||
{
|
||||
if (Luminance <= 50) {
|
||||
rm2 = l + l * (Saturation / 100);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
rm2 = l + (1 - l) * (Saturation / 100);
|
||||
}
|
||||
|
||||
@ -724,11 +704,9 @@ namespace video
|
||||
const f32 h = Hue / 360.0f;
|
||||
color.set(toRGB1(rm1, rm2, h + 1.f / 3.f),
|
||||
toRGB1(rm1, rm2, h),
|
||||
toRGB1(rm1, rm2, h - 1.f/3.f)
|
||||
);
|
||||
toRGB1(rm1, rm2, h - 1.f / 3.f));
|
||||
}
|
||||
|
||||
|
||||
// algorithm from Foley/Van-Dam
|
||||
inline f32 SColorHSL::toRGB1(f32 rm1, f32 rm2, f32 rh) const
|
||||
{
|
||||
|
@ -17,8 +17,18 @@ you are using the software or the null device.
|
||||
*/
|
||||
struct SExposedVideoData
|
||||
{
|
||||
SExposedVideoData() {OpenGLWin32.HDc=0; OpenGLWin32.HRc=0; OpenGLWin32.HWnd=0;}
|
||||
explicit SExposedVideoData(void* Window) {OpenGLWin32.HDc=0; OpenGLWin32.HRc=0; OpenGLWin32.HWnd=Window;}
|
||||
SExposedVideoData()
|
||||
{
|
||||
OpenGLWin32.HDc = 0;
|
||||
OpenGLWin32.HRc = 0;
|
||||
OpenGLWin32.HWnd = 0;
|
||||
}
|
||||
explicit SExposedVideoData(void *Window)
|
||||
{
|
||||
OpenGLWin32.HDc = 0;
|
||||
OpenGLWin32.HRc = 0;
|
||||
OpenGLWin32.HWnd = Window;
|
||||
}
|
||||
|
||||
struct SOpenGLWin32
|
||||
{
|
||||
|
@ -56,7 +56,9 @@ namespace irr
|
||||
|
||||
SIrrlichtCreationParameters(const SIrrlichtCreationParameters &other) :
|
||||
SDK_version_do_not_use(IRRLICHT_SDK_VERSION)
|
||||
{*this = other;}
|
||||
{
|
||||
*this = other;
|
||||
}
|
||||
|
||||
SIrrlichtCreationParameters &operator=(const SIrrlichtCreationParameters &other)
|
||||
{
|
||||
@ -262,5 +264,4 @@ namespace irr
|
||||
irr::io::path OGLES2ShaderPath;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace irr
|
||||
|
@ -163,8 +163,7 @@ namespace video
|
||||
//! has blend factor alphablending
|
||||
inline bool textureBlendFunc_hasAlpha(const E_BLEND_FACTOR factor)
|
||||
{
|
||||
switch ( factor )
|
||||
{
|
||||
switch (factor) {
|
||||
case EBF_SRC_ALPHA:
|
||||
case EBF_ONE_MINUS_SRC_ALPHA:
|
||||
case EBF_DST_ALPHA:
|
||||
@ -176,7 +175,6 @@ namespace video
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! These flags are used to specify the anti-aliasing and smoothing modes
|
||||
/** Techniques supported are multisampling, geometry smoothing, and alpha
|
||||
to coverage.
|
||||
@ -225,8 +223,7 @@ namespace video
|
||||
{
|
||||
"Back",
|
||||
"Front",
|
||||
0
|
||||
};
|
||||
0};
|
||||
|
||||
//! For SMaterial.ZWriteEnable
|
||||
enum E_ZWRITE
|
||||
@ -251,10 +248,7 @@ namespace video
|
||||
"Off",
|
||||
"Auto",
|
||||
"On",
|
||||
0
|
||||
};
|
||||
|
||||
|
||||
0};
|
||||
|
||||
//! Maximum number of texture an SMaterial can have.
|
||||
/** SMaterial might ignore some textures in most function, like assignment and comparison,
|
||||
@ -279,7 +273,8 @@ namespace video
|
||||
GouraudShading(true), Lighting(true), ZWriteEnable(EZW_AUTO),
|
||||
BackfaceCulling(true), FrontfaceCulling(false), FogEnable(false),
|
||||
NormalizeNormals(false), UseMipMaps(true)
|
||||
{ }
|
||||
{
|
||||
}
|
||||
|
||||
//! Texture layer array.
|
||||
SMaterialLayer TextureLayers[MATERIAL_MAX_TEXTURES];
|
||||
@ -430,7 +425,8 @@ namespace video
|
||||
/** Useful for setting properties which are not per material, but per
|
||||
texture layer, e.g. bilinear filtering. */
|
||||
template <typename F>
|
||||
void forEachTexture(F &&fn) {
|
||||
void forEachTexture(F &&fn)
|
||||
{
|
||||
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; i++) {
|
||||
fn(TextureLayers[i]);
|
||||
}
|
||||
@ -515,10 +511,8 @@ namespace video
|
||||
BlendFactor != b.BlendFactor ||
|
||||
PolygonOffsetDepthBias != b.PolygonOffsetDepthBias ||
|
||||
PolygonOffsetSlopeScale != b.PolygonOffsetSlopeScale ||
|
||||
UseMipMaps != b.UseMipMaps
|
||||
;
|
||||
for (u32 i=0; (i<MATERIAL_MAX_TEXTURES) && !different; ++i)
|
||||
{
|
||||
UseMipMaps != b.UseMipMaps;
|
||||
for (u32 i = 0; (i < MATERIAL_MAX_TEXTURES) && !different; ++i) {
|
||||
different |= (TextureLayers[i] != b.TextureLayers[i]);
|
||||
}
|
||||
return different;
|
||||
@ -528,13 +522,14 @@ namespace video
|
||||
/** \param b Material to compare to.
|
||||
\return True if the materials are equal, else false. */
|
||||
inline bool operator==(const SMaterial &b) const
|
||||
{ return !(b!=*this); }
|
||||
{
|
||||
return !(b != *this);
|
||||
}
|
||||
|
||||
//! Check if material needs alpha blending
|
||||
bool isAlphaBlendOperation() const
|
||||
{
|
||||
if (BlendOperation != EBO_NONE && BlendFactor != 0.f)
|
||||
{
|
||||
if (BlendOperation != EBO_NONE && BlendFactor != 0.f) {
|
||||
E_BLEND_FACTOR srcRGBFact = EBF_ZERO;
|
||||
E_BLEND_FACTOR dstRGBFact = EBF_ZERO;
|
||||
E_BLEND_FACTOR srcAlphaFact = EBF_ZERO;
|
||||
@ -545,8 +540,7 @@ namespace video
|
||||
unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulo, alphaSource, BlendFactor);
|
||||
|
||||
if (textureBlendFunc_hasAlpha(srcRGBFact) || textureBlendFunc_hasAlpha(dstRGBFact) ||
|
||||
textureBlendFunc_hasAlpha(srcAlphaFact) || textureBlendFunc_hasAlpha(dstAlphaFact))
|
||||
{
|
||||
textureBlendFunc_hasAlpha(srcAlphaFact) || textureBlendFunc_hasAlpha(dstAlphaFact)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
@ -42,11 +42,11 @@ namespace video
|
||||
"texture_clamp_mirror_clamp_to_edge",
|
||||
"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 {
|
||||
enum E_TEXTURE_MIN_FILTER
|
||||
{
|
||||
//! Aka nearest-neighbor.
|
||||
ETMINF_NEAREST_MIPMAP_NEAREST = 0,
|
||||
//! Aka bilinear.
|
||||
@ -61,7 +61,8 @@ namespace video
|
||||
/** Used when scaling textures up. See the documentation on OpenGL's
|
||||
`GL_TEXTURE_MAG_FILTER` for more information.
|
||||
Note that mipmaps are only used for minification, not for magnification. */
|
||||
enum E_TEXTURE_MAG_FILTER {
|
||||
enum E_TEXTURE_MAG_FILTER
|
||||
{
|
||||
//! Aka nearest-neighbor.
|
||||
ETMAGF_NEAREST = 0,
|
||||
//! Aka bilinear.
|
||||
@ -74,7 +75,8 @@ namespace video
|
||||
{
|
||||
public:
|
||||
//! Default constructor
|
||||
SMaterialLayer() : Texture(0), TextureWrapU(ETC_REPEAT), TextureWrapV(ETC_REPEAT), TextureWrapW(ETC_REPEAT),
|
||||
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)
|
||||
{
|
||||
}
|
||||
@ -91,8 +93,7 @@ namespace video
|
||||
//! Destructor
|
||||
~SMaterialLayer()
|
||||
{
|
||||
if ( TextureMatrix )
|
||||
{
|
||||
if (TextureMatrix) {
|
||||
delete TextureMatrix;
|
||||
}
|
||||
}
|
||||
@ -107,23 +108,17 @@ namespace video
|
||||
return *this;
|
||||
|
||||
Texture = other.Texture;
|
||||
if (TextureMatrix)
|
||||
{
|
||||
if (TextureMatrix) {
|
||||
if (other.TextureMatrix)
|
||||
*TextureMatrix = *other.TextureMatrix;
|
||||
else
|
||||
{
|
||||
else {
|
||||
delete TextureMatrix;
|
||||
TextureMatrix = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (other.TextureMatrix)
|
||||
{
|
||||
} else {
|
||||
if (other.TextureMatrix) {
|
||||
TextureMatrix = new core::matrix4(*other.TextureMatrix);
|
||||
}
|
||||
else
|
||||
} else
|
||||
TextureMatrix = 0;
|
||||
}
|
||||
TextureWrapU = other.TextureWrapU;
|
||||
@ -141,8 +136,7 @@ namespace video
|
||||
/** \return Texture matrix of this layer. */
|
||||
core::matrix4 &getTextureMatrix()
|
||||
{
|
||||
if (!TextureMatrix)
|
||||
{
|
||||
if (!TextureMatrix) {
|
||||
TextureMatrix = new core::matrix4();
|
||||
}
|
||||
return *TextureMatrix;
|
||||
@ -164,11 +158,9 @@ namespace video
|
||||
\param mat New texture matrix for this layer. */
|
||||
void setTextureMatrix(const core::matrix4 &mat)
|
||||
{
|
||||
if (!TextureMatrix)
|
||||
{
|
||||
if (!TextureMatrix) {
|
||||
TextureMatrix = new core::matrix4(mat);
|
||||
}
|
||||
else
|
||||
} else
|
||||
*TextureMatrix = mat;
|
||||
}
|
||||
|
||||
@ -198,7 +190,9 @@ namespace video
|
||||
/** \param b Layer to compare to.
|
||||
\return True if layers are equal, else false. */
|
||||
inline bool operator==(const SMaterialLayer &b) const
|
||||
{ return !(b!=*this); }
|
||||
{
|
||||
return !(b != *this);
|
||||
}
|
||||
|
||||
//! Texture
|
||||
ITexture *Texture;
|
||||
|
@ -41,7 +41,6 @@ namespace scene
|
||||
BoundingBox.reset(0.f, 0.f, 0.f);
|
||||
}
|
||||
|
||||
|
||||
//! returns amount of mesh buffers.
|
||||
u32 getMeshBufferCount() const override
|
||||
{
|
||||
@ -58,8 +57,7 @@ namespace scene
|
||||
/** reverse search */
|
||||
IMeshBuffer *getMeshBuffer(const video::SMaterial &material) const override
|
||||
{
|
||||
for (s32 i = (s32)MeshBuffers.size()-1; i >= 0; --i)
|
||||
{
|
||||
for (s32 i = (s32)MeshBuffers.size() - 1; i >= 0; --i) {
|
||||
if (material == MeshBuffers[i]->getMaterial())
|
||||
return MeshBuffers[i];
|
||||
}
|
||||
@ -83,21 +81,15 @@ namespace scene
|
||||
void recalculateBoundingBox()
|
||||
{
|
||||
bool hasMeshBufferBBox = false;
|
||||
for (u32 i=0; i<MeshBuffers.size(); ++i)
|
||||
{
|
||||
for (u32 i = 0; i < MeshBuffers.size(); ++i) {
|
||||
const core::aabbox3df &bb = MeshBuffers[i]->getBoundingBox();
|
||||
if ( !bb.isEmpty() )
|
||||
{
|
||||
if ( !hasMeshBufferBBox )
|
||||
{
|
||||
if (!bb.isEmpty()) {
|
||||
if (!hasMeshBufferBBox) {
|
||||
hasMeshBufferBBox = true;
|
||||
BoundingBox = bb;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
BoundingBox.addInternalBox(bb);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -109,8 +101,7 @@ namespace scene
|
||||
/** The bounding box is not updated automatically. */
|
||||
void addMeshBuffer(IMeshBuffer *buf)
|
||||
{
|
||||
if (buf)
|
||||
{
|
||||
if (buf) {
|
||||
buf->grab();
|
||||
MeshBuffers.push_back(buf);
|
||||
}
|
||||
@ -137,6 +128,5 @@ namespace scene
|
||||
core::aabbox3d<f32> BoundingBox;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -4,4 +4,3 @@
|
||||
|
||||
// replaced by template
|
||||
#include "CMeshBuffer.h"
|
||||
|
||||
|
@ -43,8 +43,10 @@ namespace video
|
||||
|
||||
struct SMaterialTypeReplacement
|
||||
{
|
||||
SMaterialTypeReplacement(s32 original, u32 replacement) : Original(original), Replacement(replacement) {}
|
||||
SMaterialTypeReplacement(u32 replacement) : Original(-1), Replacement(replacement) {}
|
||||
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)
|
||||
@ -58,7 +60,8 @@ namespace video
|
||||
core::array<SMaterialTypeReplacement> MaterialTypes;
|
||||
|
||||
//! Default constructor
|
||||
SOverrideMaterial() : EnableProps(0), EnablePasses(0), Enabled(false)
|
||||
SOverrideMaterial() :
|
||||
EnableProps(0), EnablePasses(0), Enabled(false)
|
||||
{
|
||||
}
|
||||
|
||||
@ -68,8 +71,7 @@ namespace video
|
||||
EnableProps = 0;
|
||||
EnablePasses = 0;
|
||||
Enabled = false;
|
||||
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i)
|
||||
{
|
||||
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;
|
||||
@ -80,75 +82,94 @@ namespace video
|
||||
//! Apply the enabled overrides
|
||||
void apply(SMaterial &material)
|
||||
{
|
||||
if (Enabled)
|
||||
{
|
||||
for (u32 i = 0; i < MaterialTypes.size(); ++i)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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;
|
||||
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] )
|
||||
{
|
||||
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] )
|
||||
{
|
||||
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] )
|
||||
{
|
||||
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_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] )
|
||||
{
|
||||
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_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;
|
||||
@ -156,20 +177,15 @@ namespace video
|
||||
}
|
||||
}
|
||||
}
|
||||
for(u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i )
|
||||
{
|
||||
if ( EnableLayers[i] )
|
||||
{
|
||||
for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i) {
|
||||
if (EnableLayers[i]) {
|
||||
material.TextureLayers[i] = Material.TextureLayers[i];
|
||||
}
|
||||
else if ( EnableTextures[i] )
|
||||
{
|
||||
} else if (EnableTextures[i]) {
|
||||
material.TextureLayers[i].Texture = Material.TextureLayers[i].Texture;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} // end namespace video
|
||||
|
@ -7,13 +7,11 @@
|
||||
#include "IMeshBuffer.h"
|
||||
#include "S3DVertex.h"
|
||||
|
||||
|
||||
namespace irr
|
||||
{
|
||||
namespace scene
|
||||
{
|
||||
|
||||
|
||||
//! A mesh buffer able to choose between S3DVertex2TCoords, S3DVertex and S3DVertexTangents at runtime
|
||||
struct SSkinMeshBuffer : public IMeshBuffer
|
||||
{
|
||||
@ -45,8 +43,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! Get standard vertex at given index
|
||||
virtual video::S3DVertex *getVertex(u32 index)
|
||||
{
|
||||
switch (VertexType)
|
||||
{
|
||||
switch (VertexType) {
|
||||
case video::EVT_2TCOORDS:
|
||||
return (video::S3DVertex *)&Vertices_2TCoords[index];
|
||||
case video::EVT_TANGENTS:
|
||||
@ -59,8 +56,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! Get pointer to vertex array
|
||||
const void *getVertices() const override
|
||||
{
|
||||
switch (VertexType)
|
||||
{
|
||||
switch (VertexType) {
|
||||
case video::EVT_2TCOORDS:
|
||||
return Vertices_2TCoords.const_pointer();
|
||||
case video::EVT_TANGENTS:
|
||||
@ -73,8 +69,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! Get pointer to vertex array
|
||||
void *getVertices() override
|
||||
{
|
||||
switch (VertexType)
|
||||
{
|
||||
switch (VertexType) {
|
||||
case video::EVT_2TCOORDS:
|
||||
return Vertices_2TCoords.pointer();
|
||||
case video::EVT_TANGENTS:
|
||||
@ -87,8 +82,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! Get vertex count
|
||||
u32 getVertexCount() const override
|
||||
{
|
||||
switch (VertexType)
|
||||
{
|
||||
switch (VertexType) {
|
||||
case video::EVT_2TCOORDS:
|
||||
return Vertices_2TCoords.size();
|
||||
case video::EVT_TANGENTS:
|
||||
@ -143,38 +137,31 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
|
||||
BoundingBoxNeedsRecalculated = false;
|
||||
|
||||
switch (VertexType)
|
||||
{
|
||||
case video::EVT_STANDARD:
|
||||
{
|
||||
switch (VertexType) {
|
||||
case video::EVT_STANDARD: {
|
||||
if (Vertices_Standard.empty())
|
||||
BoundingBox.reset(0, 0, 0);
|
||||
else
|
||||
{
|
||||
else {
|
||||
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:
|
||||
{
|
||||
case video::EVT_2TCOORDS: {
|
||||
if (Vertices_2TCoords.empty())
|
||||
BoundingBox.reset(0, 0, 0);
|
||||
else
|
||||
{
|
||||
else {
|
||||
BoundingBox.reset(Vertices_2TCoords[0].Pos);
|
||||
for (u32 i = 1; i < Vertices_2TCoords.size(); ++i)
|
||||
BoundingBox.addInternalPoint(Vertices_2TCoords[i].Pos);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case video::EVT_TANGENTS:
|
||||
{
|
||||
case video::EVT_TANGENTS: {
|
||||
if (Vertices_Tangents.empty())
|
||||
BoundingBox.reset(0, 0, 0);
|
||||
else
|
||||
{
|
||||
else {
|
||||
BoundingBox.reset(Vertices_Tangents[0].Pos);
|
||||
for (u32 i = 1; i < Vertices_Tangents.size(); ++i)
|
||||
BoundingBox.addInternalPoint(Vertices_Tangents[i].Pos);
|
||||
@ -193,10 +180,8 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! Convert to 2tcoords vertex type
|
||||
void convertTo2TCoords()
|
||||
{
|
||||
if (VertexType==video::EVT_STANDARD)
|
||||
{
|
||||
for(u32 n=0;n<Vertices_Standard.size();++n)
|
||||
{
|
||||
if (VertexType == video::EVT_STANDARD) {
|
||||
for (u32 n = 0; n < Vertices_Standard.size(); ++n) {
|
||||
video::S3DVertex2TCoords Vertex;
|
||||
Vertex.Color = Vertices_Standard[n].Color;
|
||||
Vertex.Pos = Vertices_Standard[n].Pos;
|
||||
@ -212,10 +197,8 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! Convert to tangents vertex type
|
||||
void convertToTangents()
|
||||
{
|
||||
if (VertexType==video::EVT_STANDARD)
|
||||
{
|
||||
for(u32 n=0;n<Vertices_Standard.size();++n)
|
||||
{
|
||||
if (VertexType == video::EVT_STANDARD) {
|
||||
for (u32 n = 0; n < Vertices_Standard.size(); ++n) {
|
||||
video::S3DVertexTangents Vertex;
|
||||
Vertex.Color = Vertices_Standard[n].Color;
|
||||
Vertex.Pos = Vertices_Standard[n].Pos;
|
||||
@ -225,11 +208,8 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
}
|
||||
Vertices_Standard.clear();
|
||||
VertexType = video::EVT_TANGENTS;
|
||||
}
|
||||
else if (VertexType==video::EVT_2TCOORDS)
|
||||
{
|
||||
for(u32 n=0;n<Vertices_2TCoords.size();++n)
|
||||
{
|
||||
} else if (VertexType == video::EVT_2TCOORDS) {
|
||||
for (u32 n = 0; n < Vertices_2TCoords.size(); ++n) {
|
||||
video::S3DVertexTangents Vertex;
|
||||
Vertex.Color = Vertices_2TCoords[n].Color;
|
||||
Vertex.Pos = Vertices_2TCoords[n].Pos;
|
||||
@ -245,8 +225,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! returns position of vertex i
|
||||
const core::vector3df &getPosition(u32 i) const override
|
||||
{
|
||||
switch (VertexType)
|
||||
{
|
||||
switch (VertexType) {
|
||||
case video::EVT_2TCOORDS:
|
||||
return Vertices_2TCoords[i].Pos;
|
||||
case video::EVT_TANGENTS:
|
||||
@ -259,8 +238,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! returns position of vertex i
|
||||
core::vector3df &getPosition(u32 i) override
|
||||
{
|
||||
switch (VertexType)
|
||||
{
|
||||
switch (VertexType) {
|
||||
case video::EVT_2TCOORDS:
|
||||
return Vertices_2TCoords[i].Pos;
|
||||
case video::EVT_TANGENTS:
|
||||
@ -273,8 +251,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! returns normal of vertex i
|
||||
const core::vector3df &getNormal(u32 i) const override
|
||||
{
|
||||
switch (VertexType)
|
||||
{
|
||||
switch (VertexType) {
|
||||
case video::EVT_2TCOORDS:
|
||||
return Vertices_2TCoords[i].Normal;
|
||||
case video::EVT_TANGENTS:
|
||||
@ -287,8 +264,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! returns normal of vertex i
|
||||
core::vector3df &getNormal(u32 i) override
|
||||
{
|
||||
switch (VertexType)
|
||||
{
|
||||
switch (VertexType) {
|
||||
case video::EVT_2TCOORDS:
|
||||
return Vertices_2TCoords[i].Normal;
|
||||
case video::EVT_TANGENTS:
|
||||
@ -301,8 +277,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! returns texture coords of vertex i
|
||||
const core::vector2df &getTCoords(u32 i) const override
|
||||
{
|
||||
switch (VertexType)
|
||||
{
|
||||
switch (VertexType) {
|
||||
case video::EVT_2TCOORDS:
|
||||
return Vertices_2TCoords[i].TCoords;
|
||||
case video::EVT_TANGENTS:
|
||||
@ -315,8 +290,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
//! returns texture coords of vertex i
|
||||
core::vector2df &getTCoords(u32 i) override
|
||||
{
|
||||
switch (VertexType)
|
||||
{
|
||||
switch (VertexType) {
|
||||
case video::EVT_2TCOORDS:
|
||||
return Vertices_2TCoords[i].TCoords;
|
||||
case video::EVT_TANGENTS:
|
||||
@ -348,8 +322,7 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
MappingHint_Vertex = NewMappingHint;
|
||||
else if (Buffer == EBT_INDEX)
|
||||
MappingHint_Index = NewMappingHint;
|
||||
else if (Buffer==EBT_VERTEX_AND_INDEX)
|
||||
{
|
||||
else if (Buffer == EBT_VERTEX_AND_INDEX) {
|
||||
MappingHint_Vertex = NewMappingHint;
|
||||
MappingHint_Index = NewMappingHint;
|
||||
}
|
||||
@ -380,15 +353,16 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
|
||||
u32 getChangedID_Index() const override { return ChangedID_Index; }
|
||||
|
||||
void setHWBuffer(void *ptr) const override {
|
||||
void setHWBuffer(void *ptr) const override
|
||||
{
|
||||
HWBuffer = ptr;
|
||||
}
|
||||
|
||||
void *getHWBuffer() const override {
|
||||
void *getHWBuffer() const override
|
||||
{
|
||||
return HWBuffer;
|
||||
}
|
||||
|
||||
|
||||
//! Call this after changing the positions of any vertex.
|
||||
void boundingBoxNeedsRecalculated(void) { BoundingBoxNeedsRecalculated = true; }
|
||||
|
||||
@ -420,6 +394,5 @@ struct SSkinMeshBuffer : public IMeshBuffer
|
||||
bool BoundingBoxNeedsRecalculated : 1;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
@ -6,7 +6,6 @@
|
||||
|
||||
#include "irrTypes.h"
|
||||
|
||||
|
||||
namespace irr
|
||||
{
|
||||
namespace video
|
||||
@ -17,6 +16,5 @@ enum E_INDEX_TYPE
|
||||
EIT_32BIT
|
||||
};
|
||||
|
||||
|
||||
} // end namespace video
|
||||
} // end namespace irr
|
||||
|
@ -28,12 +28,14 @@ namespace scene
|
||||
class SVertexPositionScaleManipulator : public IVertexManipulator
|
||||
{
|
||||
public:
|
||||
SVertexPositionScaleManipulator(const core::vector3df& factor) : Factor(factor) {}
|
||||
SVertexPositionScaleManipulator(const core::vector3df &factor) :
|
||||
Factor(factor) {}
|
||||
template <typename VType>
|
||||
void operator()(VType &vertex) const
|
||||
{
|
||||
vertex.Pos *= Factor;
|
||||
}
|
||||
|
||||
private:
|
||||
core::vector3df Factor;
|
||||
};
|
||||
|
@ -42,9 +42,9 @@ namespace scene
|
||||
VF_PLANE_COUNT
|
||||
};
|
||||
|
||||
|
||||
//! Default Constructor
|
||||
SViewFrustum() : BoundingRadius(0.f), FarNearDistance(0.f) {}
|
||||
SViewFrustum() :
|
||||
BoundingRadius(0.f), FarNearDistance(0.f) {}
|
||||
|
||||
//! Copy Constructor
|
||||
SViewFrustum(const SViewFrustum &other);
|
||||
@ -139,7 +139,6 @@ namespace scene
|
||||
core::vector3df BoundingCenter;
|
||||
};
|
||||
|
||||
|
||||
/*!
|
||||
Copy constructor ViewFrustum
|
||||
*/
|
||||
@ -165,7 +164,6 @@ namespace scene
|
||||
setFrom(mat, zClipFromZero);
|
||||
}
|
||||
|
||||
|
||||
inline void SViewFrustum::transform(const core::matrix4 &mat)
|
||||
{
|
||||
for (u32 i = 0; i < VF_PLANE_COUNT; ++i)
|
||||
@ -175,7 +173,6 @@ namespace scene
|
||||
recalculateBoundingBox();
|
||||
}
|
||||
|
||||
|
||||
inline core::vector3df SViewFrustum::getFarLeftUp() const
|
||||
{
|
||||
core::vector3df p;
|
||||
@ -326,15 +323,12 @@ namespace scene
|
||||
planes[VF_FAR_PLANE].D = mat[15] - mat[14];
|
||||
|
||||
// near clipping plane
|
||||
if ( zClipFromZero )
|
||||
{
|
||||
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
|
||||
{
|
||||
} else {
|
||||
// near clipping plane
|
||||
planes[VF_NEAR_PLANE].Normal.X = mat[3] + mat[2];
|
||||
planes[VF_NEAR_PLANE].Normal.Y = mat[7] + mat[6];
|
||||
@ -344,8 +338,7 @@ namespace scene
|
||||
|
||||
// normalize normals
|
||||
u32 i;
|
||||
for ( i=0; i != VF_PLANE_COUNT; ++i)
|
||||
{
|
||||
for (i = 0; i != VF_PLANE_COUNT; ++i) {
|
||||
const f32 len = -core::reciprocal_squareroot(
|
||||
planes[i].Normal.getLengthSQ());
|
||||
planes[i].Normal *= len;
|
||||
@ -362,12 +355,13 @@ namespace scene
|
||||
inline core::matrix4 &SViewFrustum::getTransform(video::E_TRANSFORMATION_STATE state)
|
||||
{
|
||||
u32 index = 0;
|
||||
switch ( state )
|
||||
{
|
||||
switch (state) {
|
||||
case video::ETS_PROJECTION:
|
||||
index = SViewFrustum::ETS_PROJECTION; break;
|
||||
index = SViewFrustum::ETS_PROJECTION;
|
||||
break;
|
||||
case video::ETS_VIEW:
|
||||
index = SViewFrustum::ETS_VIEW; break;
|
||||
index = SViewFrustum::ETS_VIEW;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -380,12 +374,13 @@ namespace scene
|
||||
inline const core::matrix4 &SViewFrustum::getTransform(video::E_TRANSFORMATION_STATE state) const
|
||||
{
|
||||
u32 index = 0;
|
||||
switch ( state )
|
||||
{
|
||||
switch (state) {
|
||||
case video::ETS_PROJECTION:
|
||||
index = SViewFrustum::ETS_PROJECTION; break;
|
||||
index = SViewFrustum::ETS_PROJECTION;
|
||||
break;
|
||||
case video::ETS_VIEW:
|
||||
index = SViewFrustum::ETS_VIEW; break;
|
||||
index = SViewFrustum::ETS_VIEW;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -396,16 +391,13 @@ namespace scene
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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;
|
||||
@ -445,8 +437,7 @@ namespace scene
|
||||
|
||||
float longest = 0;
|
||||
|
||||
for (i = 0; i < 8; ++i)
|
||||
{
|
||||
for (i = 0; i < 8; ++i) {
|
||||
if (diam[i] > longest)
|
||||
longest = diam[i];
|
||||
}
|
||||
|
@ -38,7 +38,6 @@ namespace scene
|
||||
**/
|
||||
const c8 *const OBJ_LOADER_IGNORE_GROUPS = "OBJ_IgnoreGroups";
|
||||
|
||||
|
||||
//! Flag to avoid loading material .mtl file for .obj files
|
||||
/** Use it like this:
|
||||
\code
|
||||
|
@ -20,13 +20,15 @@ template <class T>
|
||||
class aabbox3d
|
||||
{
|
||||
public:
|
||||
|
||||
//! Default Constructor.
|
||||
constexpr aabbox3d(): MinEdge(-1,-1,-1), MaxEdge(1,1,1) {}
|
||||
constexpr aabbox3d() :
|
||||
MinEdge(-1, -1, -1), MaxEdge(1, 1, 1) {}
|
||||
//! 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) :
|
||||
MinEdge(min), MaxEdge(max) {}
|
||||
//! Constructor with only one point.
|
||||
constexpr aabbox3d(const vector3d<T>& init): MinEdge(init), MaxEdge(init) {}
|
||||
constexpr aabbox3d(const vector3d<T> &init) :
|
||||
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) {}
|
||||
@ -36,12 +38,16 @@ class aabbox3d
|
||||
/** \param other box to compare with.
|
||||
\return True if both boxes are equal, else false. */
|
||||
constexpr inline bool operator==(const aabbox3d<T> &other) const
|
||||
{ return (MinEdge == other.MinEdge && other.MaxEdge == MaxEdge); }
|
||||
{
|
||||
return (MinEdge == other.MinEdge && other.MaxEdge == MaxEdge);
|
||||
}
|
||||
//! Inequality operator
|
||||
/** \param other box to compare with.
|
||||
\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); }
|
||||
{
|
||||
return !(MinEdge == other.MinEdge && other.MaxEdge == MaxEdge);
|
||||
}
|
||||
|
||||
// functions
|
||||
|
||||
@ -94,13 +100,19 @@ class aabbox3d
|
||||
\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 > 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;
|
||||
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
|
||||
@ -183,20 +195,32 @@ class aabbox3d
|
||||
{
|
||||
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; }
|
||||
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;
|
||||
if (MinEdge.X > MaxEdge.X)
|
||||
return false;
|
||||
if (MinEdge.Y > MaxEdge.Y)
|
||||
return false;
|
||||
if (MinEdge.Z > MaxEdge.Z)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -325,20 +349,17 @@ class aabbox3d
|
||||
vector3d<T> nearPoint(MaxEdge);
|
||||
vector3d<T> farPoint(MinEdge);
|
||||
|
||||
if (plane.Normal.X > (T)0)
|
||||
{
|
||||
if (plane.Normal.X > (T)0) {
|
||||
nearPoint.X = MinEdge.X;
|
||||
farPoint.X = MaxEdge.X;
|
||||
}
|
||||
|
||||
if (plane.Normal.Y > (T)0)
|
||||
{
|
||||
if (plane.Normal.Y > (T)0) {
|
||||
nearPoint.Y = MinEdge.Y;
|
||||
farPoint.Y = MaxEdge.Y;
|
||||
}
|
||||
|
||||
if (plane.Normal.Z > (T)0)
|
||||
{
|
||||
if (plane.Normal.Z > (T)0) {
|
||||
nearPoint.Z = MinEdge.Z;
|
||||
farPoint.Z = MaxEdge.Z;
|
||||
}
|
||||
|
@ -73,8 +73,7 @@ inline io::path& deletePathFromFilename(io::path& filename)
|
||||
while (*p != '/' && *p != '\\' && p != s)
|
||||
p--;
|
||||
|
||||
if ( p != s )
|
||||
{
|
||||
if (p != s) {
|
||||
++p;
|
||||
filename = p;
|
||||
}
|
||||
@ -88,22 +87,18 @@ inline io::path& deletePathFromPath(io::path& filename, s32 pathCount)
|
||||
s32 i = filename.size();
|
||||
|
||||
// search for path separator or beginning
|
||||
while ( i>=0 )
|
||||
{
|
||||
if ( filename[i] == '/' || filename[i] == '\\' )
|
||||
{
|
||||
while (i >= 0) {
|
||||
if (filename[i] == '/' || filename[i] == '\\') {
|
||||
if (--pathCount <= 0)
|
||||
break;
|
||||
}
|
||||
--i;
|
||||
}
|
||||
|
||||
if ( i>0 )
|
||||
{
|
||||
if (i > 0) {
|
||||
filename[i + 1] = 0;
|
||||
filename.validate();
|
||||
}
|
||||
else
|
||||
} else
|
||||
filename = "";
|
||||
return filename;
|
||||
}
|
||||
@ -118,15 +113,13 @@ inline s32 isInSameDirectory ( const io::path& path, const io::path& file )
|
||||
s32 subA = 0;
|
||||
s32 subB = 0;
|
||||
s32 pos = 0;
|
||||
while ( (pos = path.findNext ( '/', pos )) >= 0 )
|
||||
{
|
||||
while ((pos = path.findNext('/', pos)) >= 0) {
|
||||
subA += 1;
|
||||
pos += 1;
|
||||
}
|
||||
|
||||
pos = 0;
|
||||
while ( (pos = file.findNext ( '/', pos )) >= 0 )
|
||||
{
|
||||
while ((pos = file.findNext('/', pos)) >= 0) {
|
||||
subB += 1;
|
||||
pos += 1;
|
||||
}
|
||||
@ -142,21 +135,15 @@ static inline void splitFilename(const io::path &name, io::path* path=0,
|
||||
s32 extpos = i;
|
||||
|
||||
// search for path separator or beginning
|
||||
while ( i >= 0 )
|
||||
{
|
||||
if ( name[i] == '.' )
|
||||
{
|
||||
while (i >= 0) {
|
||||
if (name[i] == '.') {
|
||||
extpos = i;
|
||||
if (extension)
|
||||
*extension = name.subString(extpos + 1, name.size() - (extpos + 1), make_lower);
|
||||
}
|
||||
else
|
||||
if ( name[i] == '/' || name[i] == '\\' )
|
||||
{
|
||||
} else if (name[i] == '/' || name[i] == '\\') {
|
||||
if (filename)
|
||||
*filename = name.subString(i + 1, extpos - (i + 1), make_lower);
|
||||
if ( path )
|
||||
{
|
||||
if (path) {
|
||||
*path = name.subString(0, i + 1, make_lower);
|
||||
path->replace('\\', '/');
|
||||
}
|
||||
@ -173,16 +160,14 @@ static inline io::path mergeFilename(const io::path& path, const io::path& filen
|
||||
{
|
||||
io::path result(path);
|
||||
|
||||
if ( !result.empty() )
|
||||
{
|
||||
if (!result.empty()) {
|
||||
fschar_t last = result.lastChar();
|
||||
if (last != _IRR_TEXT('/') && last != _IRR_TEXT('\\'))
|
||||
result += _IRR_TEXT('/');
|
||||
}
|
||||
if (!filename.empty())
|
||||
result += filename;
|
||||
if ( !extension.empty() )
|
||||
{
|
||||
if (!extension.empty()) {
|
||||
if (!result.empty() && extension[0] != _IRR_TEXT('.'))
|
||||
result += _IRR_TEXT('.');
|
||||
result += extension;
|
||||
@ -191,13 +176,19 @@ static inline io::path mergeFilename(const io::path& path, const io::path& filen
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
//! some standard function ( to remove dependencies )
|
||||
inline bool isdigit(s32 c) { 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'; }
|
||||
|
||||
inline bool isdigit(s32 c)
|
||||
{
|
||||
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 irr
|
||||
|
||||
|
@ -20,17 +20,20 @@ namespace core
|
||||
{
|
||||
public:
|
||||
//! Default constructor for empty dimension
|
||||
constexpr dimension2d() : Width(0), Height(0) {}
|
||||
constexpr dimension2d() :
|
||||
Width(0), Height(0) {}
|
||||
//! Constructor with width and height
|
||||
constexpr dimension2d(const T& width, const T& height)
|
||||
: Width(width), Height(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) { }
|
||||
Width((T)other.Width), Height((T)other.Height)
|
||||
{
|
||||
}
|
||||
|
||||
template <class U>
|
||||
dimension2d<T> &operator=(const dimension2d<U> &other)
|
||||
@ -40,7 +43,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Equality operator
|
||||
bool operator==(const dimension2d<T> &other) const
|
||||
{
|
||||
@ -154,8 +156,7 @@ namespace core
|
||||
{
|
||||
u32 i = 1;
|
||||
u32 j = 1;
|
||||
if (requirePowerOfTwo)
|
||||
{
|
||||
if (requirePowerOfTwo) {
|
||||
while (i < (u32)Width)
|
||||
i <<= 1;
|
||||
if (!larger && i != 1 && i != (u32)Width)
|
||||
@ -164,15 +165,12 @@ namespace core
|
||||
j <<= 1;
|
||||
if (!larger && j != 1 && j != (u32)Height)
|
||||
j >>= 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
i = (u32)Width;
|
||||
j = (u32)Height;
|
||||
}
|
||||
|
||||
if (requireSquare)
|
||||
{
|
||||
if (requireSquare) {
|
||||
if ((larger && (i > j)) || (!larger && (i < j)))
|
||||
j = i;
|
||||
else
|
||||
@ -198,7 +196,6 @@ namespace core
|
||||
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.
|
||||
@ -215,8 +212,5 @@ namespace core
|
||||
dimension2du instead. */
|
||||
typedef dimension2d<s32> dimension2di;
|
||||
|
||||
|
||||
} // end namespace core
|
||||
} // end namespace irr
|
||||
|
||||
|
||||
|
@ -31,8 +31,7 @@ const float fast_atof_table[17] = {
|
||||
0.0000000000001f,
|
||||
0.00000000000001f,
|
||||
0.000000000000001f,
|
||||
0.0000000000000001f
|
||||
};
|
||||
0.0000000000000001f};
|
||||
|
||||
//! 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
|
||||
@ -44,8 +43,7 @@ const float fast_atof_table[17] = {
|
||||
*/
|
||||
inline u32 strtoul10(const char *in, const char **out = 0)
|
||||
{
|
||||
if (!in)
|
||||
{
|
||||
if (!in) {
|
||||
if (out)
|
||||
*out = in;
|
||||
return 0;
|
||||
@ -53,11 +51,9 @@ inline u32 strtoul10(const char* in, const char** out=0)
|
||||
|
||||
bool overflow = false;
|
||||
u32 unsignedValue = 0;
|
||||
while ( ( *in >= '0') && ( *in <= '9' ))
|
||||
{
|
||||
while ((*in >= '0') && (*in <= '9')) {
|
||||
const u32 tmp = (unsignedValue * 10) + (*in - '0');
|
||||
if (tmp<unsignedValue)
|
||||
{
|
||||
if (tmp < unsignedValue) {
|
||||
unsignedValue = (u32)0xffffffff;
|
||||
overflow = true;
|
||||
}
|
||||
@ -84,8 +80,7 @@ inline u32 strtoul10(const char* in, const char** out=0)
|
||||
*/
|
||||
inline s32 strtol10(const char *in, const char **out = 0)
|
||||
{
|
||||
if (!in)
|
||||
{
|
||||
if (!in) {
|
||||
if (out)
|
||||
*out = in;
|
||||
return 0;
|
||||
@ -96,15 +91,12 @@ inline s32 strtol10(const char* in, const char** out=0)
|
||||
++in;
|
||||
|
||||
const u32 unsignedValue = strtoul10(in, out);
|
||||
if (unsignedValue > (u32)INT_MAX)
|
||||
{
|
||||
if (unsignedValue > (u32)INT_MAX) {
|
||||
if (negative)
|
||||
return (s32)INT_MIN;
|
||||
else
|
||||
return (s32)INT_MAX;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
if (negative)
|
||||
return -((s32)unsignedValue);
|
||||
else
|
||||
@ -141,8 +133,7 @@ inline u32 ctoul16(char in)
|
||||
*/
|
||||
inline u32 strtoul16(const char *in, const char **out = 0)
|
||||
{
|
||||
if (!in)
|
||||
{
|
||||
if (!in) {
|
||||
if (out)
|
||||
*out = in;
|
||||
return 0;
|
||||
@ -150,8 +141,7 @@ inline u32 strtoul16(const char* in, const char** out=0)
|
||||
|
||||
bool overflow = false;
|
||||
u32 unsignedValue = 0;
|
||||
while (true)
|
||||
{
|
||||
while (true) {
|
||||
u32 tmp = 0;
|
||||
if ((*in >= '0') && (*in <= '9'))
|
||||
tmp = (unsignedValue << 4u) + (*in - '0');
|
||||
@ -161,8 +151,7 @@ inline u32 strtoul16(const char* in, const char** out=0)
|
||||
tmp = (unsignedValue << 4u) + (*in - 'a') + 10;
|
||||
else
|
||||
break;
|
||||
if (tmp<unsignedValue)
|
||||
{
|
||||
if (tmp < unsignedValue) {
|
||||
unsignedValue = (u32)INT_MAX;
|
||||
overflow = true;
|
||||
}
|
||||
@ -188,8 +177,7 @@ inline u32 strtoul16(const char* in, const char** out=0)
|
||||
*/
|
||||
inline u32 strtoul8(const char *in, const char **out = 0)
|
||||
{
|
||||
if (!in)
|
||||
{
|
||||
if (!in) {
|
||||
if (out)
|
||||
*out = in;
|
||||
return 0;
|
||||
@ -197,15 +185,13 @@ inline u32 strtoul8(const char* in, const char** out=0)
|
||||
|
||||
bool overflow = false;
|
||||
u32 unsignedValue = 0;
|
||||
while (true)
|
||||
{
|
||||
while (true) {
|
||||
u32 tmp = 0;
|
||||
if ((*in >= '0') && (*in <= '7'))
|
||||
tmp = (unsignedValue << 3u) + (*in - '0');
|
||||
else
|
||||
break;
|
||||
if (tmp<unsignedValue)
|
||||
{
|
||||
if (tmp < unsignedValue) {
|
||||
unsignedValue = (u32)INT_MAX;
|
||||
overflow = true;
|
||||
}
|
||||
@ -231,8 +217,7 @@ inline u32 strtoul8(const char* in, const char** out=0)
|
||||
*/
|
||||
inline u32 strtoul_prefix(const char *in, const char **out = 0)
|
||||
{
|
||||
if (!in)
|
||||
{
|
||||
if (!in) {
|
||||
if (out)
|
||||
*out = in;
|
||||
return 0;
|
||||
@ -253,8 +238,7 @@ inline u32 strtoul_prefix(const char* in, const char** out=0)
|
||||
*/
|
||||
inline f32 strtof10(const char *in, const char **out = 0)
|
||||
{
|
||||
if (!in)
|
||||
{
|
||||
if (!in) {
|
||||
if (out)
|
||||
*out = in;
|
||||
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
|
||||
// and precision.
|
||||
while ( ( *in >= '0') && ( *in <= '9' ) )
|
||||
{
|
||||
while ((*in >= '0') && (*in <= '9')) {
|
||||
// If it looks like we're going to overflow, bail out
|
||||
// now and start using floating point.
|
||||
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
|
||||
// floating point arithmetic from here.
|
||||
while ( ( *in >= '0') && ( *in <= '9' ) )
|
||||
{
|
||||
while ((*in >= '0') && (*in <= '9')) {
|
||||
floatValue = (floatValue * 10.f) + (f32)(*in - '0');
|
||||
++in;
|
||||
if (floatValue > FLT_MAX) // Just give up.
|
||||
@ -316,24 +298,19 @@ inline const char* fast_atof_move(const char* in, f32& result)
|
||||
|
||||
f32 value = strtof10(in, &in);
|
||||
|
||||
if ( *in == '.' )
|
||||
{
|
||||
if (*in == '.') {
|
||||
const char *afterDecimal = ++in;
|
||||
const f32 decimal = strtof10(in, &afterDecimal);
|
||||
const size_t numDecimals = afterDecimal - in;
|
||||
if (numDecimals < IRR_ATOF_TABLE_SIZE)
|
||||
{
|
||||
if (numDecimals < IRR_ATOF_TABLE_SIZE) {
|
||||
value += decimal * fast_atof_table[numDecimals];
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
value += decimal * (f32)pow(10.f, -(float)numDecimals);
|
||||
}
|
||||
in = afterDecimal;
|
||||
}
|
||||
|
||||
if ('e' == *in || 'E' == *in)
|
||||
{
|
||||
if ('e' == *in || 'E' == *in) {
|
||||
++in;
|
||||
// Assume that the exponent is a whole number.
|
||||
// strtol10() will deal with both + and - signs,
|
||||
|
@ -26,19 +26,24 @@ public:
|
||||
"irr::core::array<T> with T = bool not supported. Use std::vector instead.");
|
||||
|
||||
//! Default constructor for empty array.
|
||||
array() : m_data(), is_sorted(true)
|
||||
{ }
|
||||
array() :
|
||||
m_data(), is_sorted(true)
|
||||
{
|
||||
}
|
||||
|
||||
//! Constructs an array and allocates an initial chunk of memory.
|
||||
/** \param start_count Amount of elements to pre-allocate. */
|
||||
explicit array(u32 start_count) : m_data(), is_sorted(true)
|
||||
explicit array(u32 start_count) :
|
||||
m_data(), is_sorted(true)
|
||||
{
|
||||
m_data.reserve(start_count);
|
||||
}
|
||||
|
||||
//! Copy constructor
|
||||
array(const array<T>& other) : m_data(other.m_data), is_sorted(other.is_sorted)
|
||||
{ }
|
||||
array(const array<T> &other) :
|
||||
m_data(other.m_data), is_sorted(other.is_sorted)
|
||||
{
|
||||
}
|
||||
|
||||
//! Reallocates the array, make it bigger or smaller.
|
||||
/** \param new_size New size of array.
|
||||
@ -72,7 +77,6 @@ public:
|
||||
is_sorted = false;
|
||||
}
|
||||
|
||||
|
||||
//! Adds an element at the front of the array.
|
||||
/** If the array is to small to add this new element, the array is
|
||||
made bigger. Please note that this is slow, because the whole array
|
||||
@ -90,7 +94,6 @@ public:
|
||||
is_sorted = false;
|
||||
}
|
||||
|
||||
|
||||
//! Insert item into array at specified position.
|
||||
/**
|
||||
\param element: Element to be inserted
|
||||
@ -177,14 +180,12 @@ public:
|
||||
return equals(other.const_pointer(), other.size());
|
||||
}
|
||||
|
||||
|
||||
//! Inequality operator
|
||||
bool operator!=(const array<T> &other) const
|
||||
{
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
|
||||
//! Direct access operator
|
||||
T &operator[](u32 index)
|
||||
{
|
||||
@ -193,7 +194,6 @@ public:
|
||||
return m_data[index];
|
||||
}
|
||||
|
||||
|
||||
//! Direct const access operator
|
||||
const T &operator[](u32 index) const
|
||||
{
|
||||
@ -202,7 +202,6 @@ public:
|
||||
return m_data[index];
|
||||
}
|
||||
|
||||
|
||||
//! Gets last element.
|
||||
T &getLast()
|
||||
{
|
||||
@ -211,7 +210,6 @@ public:
|
||||
return m_data.back();
|
||||
}
|
||||
|
||||
|
||||
//! Gets last element
|
||||
const T &getLast() const
|
||||
{
|
||||
@ -220,7 +218,6 @@ public:
|
||||
return m_data.back();
|
||||
}
|
||||
|
||||
|
||||
//! Gets a pointer to the array.
|
||||
/** \return Pointer to the array. */
|
||||
T *pointer()
|
||||
@ -228,7 +225,6 @@ public:
|
||||
return m_data.empty() ? nullptr : &m_data[0];
|
||||
}
|
||||
|
||||
|
||||
//! Gets a const pointer to the array.
|
||||
/** \return Pointer to the array. */
|
||||
const T *const_pointer() const
|
||||
@ -236,7 +232,6 @@ public:
|
||||
return m_data.empty() ? nullptr : &m_data[0];
|
||||
}
|
||||
|
||||
|
||||
//! Get number of occupied elements of the array.
|
||||
/** \return Size of elements in the array which are actually occupied. */
|
||||
u32 size() const
|
||||
@ -244,7 +239,6 @@ public:
|
||||
return static_cast<u32>(m_data.size());
|
||||
}
|
||||
|
||||
|
||||
//! Get amount of memory allocated.
|
||||
/** \return Amount of memory allocated. The amount of bytes
|
||||
allocated would be allocated_size() * sizeof(ElementTypeUsed); */
|
||||
@ -253,7 +247,6 @@ public:
|
||||
return m_data.capacity();
|
||||
}
|
||||
|
||||
|
||||
//! Check if array is empty.
|
||||
/** \return True if the array is empty false if not. */
|
||||
bool empty() const
|
||||
@ -261,7 +254,6 @@ public:
|
||||
return m_data.empty();
|
||||
}
|
||||
|
||||
|
||||
//! Sorts the array using heapsort.
|
||||
/** There is no additional memory waste and the algorithm performs
|
||||
O(n*log n) in worst case. */
|
||||
@ -273,7 +265,6 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//! Performs a binary search for an element, returns -1 if not found.
|
||||
/** The array will be sorted before the binary search if it is not
|
||||
already sorted. Caution is advised! Be careful not to call this on
|
||||
@ -320,7 +311,6 @@ public:
|
||||
return static_cast<u32>(it - m_data.begin());
|
||||
}
|
||||
|
||||
|
||||
//! Performs a binary search for an element, returns -1 if not found.
|
||||
//! it is used for searching a multiset
|
||||
/** The array will be sorted before the binary search if it is not
|
||||
@ -339,7 +329,6 @@ public:
|
||||
return static_cast<s32>(iters.first - m_data.begin());
|
||||
}
|
||||
|
||||
|
||||
//! Finds an element in linear time, which is very slow.
|
||||
/** Use binary_search for faster finding. Only works if ==operator is
|
||||
implemented.
|
||||
@ -354,7 +343,6 @@ public:
|
||||
return static_cast<u32>(it - m_data.begin());
|
||||
}
|
||||
|
||||
|
||||
//! Finds an element in linear time, which is very slow.
|
||||
/** Use binary_search for faster finding. Only works if ==operator is
|
||||
implemented.
|
||||
@ -370,7 +358,6 @@ public:
|
||||
return m_data.size() - offset - 1;
|
||||
}
|
||||
|
||||
|
||||
//! Erases an element from the array.
|
||||
/** May be slow, because all elements following after the erased
|
||||
element have to be copied.
|
||||
@ -382,7 +369,6 @@ public:
|
||||
m_data.erase(it);
|
||||
}
|
||||
|
||||
|
||||
//! Erases some elements from the array.
|
||||
/** May be slow, because all elements following after the erased
|
||||
element have to be copied.
|
||||
@ -404,7 +390,6 @@ public:
|
||||
is_sorted = _is_sorted;
|
||||
}
|
||||
|
||||
|
||||
//! Swap the content of this array container with the content of another array
|
||||
/** Afterward this object will contain the content of the other object and the other
|
||||
object will contain the content of this object.
|
||||
@ -435,5 +420,3 @@ private:
|
||||
|
||||
} // end namespace core
|
||||
} // end namespace irr
|
||||
|
||||
|
||||
|
@ -216,7 +216,8 @@ namespace core
|
||||
|
||||
union FloatIntUnion32
|
||||
{
|
||||
FloatIntUnion32(float f1 = 0.0f) : f(f1) {}
|
||||
FloatIntUnion32(float f1 = 0.0f) :
|
||||
f(f1) {}
|
||||
// Portable sign-extraction
|
||||
bool sign() const { return (i >> 31) != 0; }
|
||||
|
||||
@ -238,8 +239,7 @@ namespace core
|
||||
const FloatIntUnion32 fb(b);
|
||||
|
||||
// Different signs, we could maybe get difference to 0, but so close to 0 using epsilons is better.
|
||||
if ( fa.sign() != fb.sign() )
|
||||
{
|
||||
if (fa.sign() != fb.sign()) {
|
||||
// Check for equality to make sure +0==-0
|
||||
if (fa.i == fb.i)
|
||||
return true;
|
||||
@ -318,7 +318,12 @@ namespace core
|
||||
in general: number = (sign ? -1:1) * 2^(exponent) * 1.(mantissa bits)
|
||||
*/
|
||||
|
||||
typedef union { u32 u; s32 s; f32 f; } inttofloat;
|
||||
typedef union
|
||||
{
|
||||
u32 u;
|
||||
s32 s;
|
||||
f32 f;
|
||||
} inttofloat;
|
||||
|
||||
#define F32_AS_S32(f) (*((s32 *)&(f)))
|
||||
#define F32_AS_U32(f) (*((u32 *)&(f)))
|
||||
@ -329,11 +334,26 @@ namespace core
|
||||
|
||||
//! code is taken from IceFPU
|
||||
//! Integer representation of a floating-point value.
|
||||
inline u32 IR(f32 x) {inttofloat tmp; tmp.f=x; return tmp.u;}
|
||||
inline u32 IR(f32 x)
|
||||
{
|
||||
inttofloat tmp;
|
||||
tmp.f = x;
|
||||
return tmp.u;
|
||||
}
|
||||
|
||||
//! Floating-point representation of an integer value.
|
||||
inline f32 FR(u32 x) {inttofloat tmp; tmp.u=x; return tmp.f;}
|
||||
inline f32 FR(s32 x) {inttofloat tmp; tmp.s=x; return tmp.f;}
|
||||
inline f32 FR(u32 x)
|
||||
{
|
||||
inttofloat tmp;
|
||||
tmp.u = x;
|
||||
return tmp.f;
|
||||
}
|
||||
inline f32 FR(s32 x)
|
||||
{
|
||||
inttofloat tmp;
|
||||
tmp.s = x;
|
||||
return tmp.f;
|
||||
}
|
||||
|
||||
#define F32_LOWER_0(n) ((n) < 0.0f)
|
||||
#define F32_LOWER_EQUAL_0(n) ((n) <= 0.0f)
|
||||
@ -351,7 +371,6 @@ namespace core
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
// NOTE: This is not as exact as the c99/c++11 round function, especially at high numbers starting with 8388609
|
||||
// (only low number which seems to go wrong is 0.49999997 which is rounded to 1)
|
||||
// Also negative 0.5 is rounded up not down unlike with the standard function (p.E. input -0.5 will be 0 and not -1)
|
||||
@ -414,7 +433,6 @@ namespace core
|
||||
return 1.0 / f;
|
||||
}
|
||||
|
||||
|
||||
// calculate: 1 / x, low precision allowed
|
||||
REALINLINE f32 reciprocal_approxim(const f32 f)
|
||||
{
|
||||
@ -455,6 +473,5 @@ namespace core
|
||||
} // end namespace core
|
||||
} // end namespace irr
|
||||
|
||||
using irr::core::IR;
|
||||
using irr::core::FR;
|
||||
|
||||
using irr::core::IR;
|
||||
|
@ -43,7 +43,6 @@ typedef string<c8> stringc;
|
||||
//! Typedef for wide character strings
|
||||
typedef string<wchar_t> stringw;
|
||||
|
||||
|
||||
//! Returns a character converted to lower case
|
||||
static inline u32 locale_lower(u32 x)
|
||||
{
|
||||
@ -58,18 +57,16 @@ static inline u32 locale_upper ( u32 x )
|
||||
return x >= 'a' && x <= 'z' ? x + ('A' - 'a') : x;
|
||||
}
|
||||
|
||||
|
||||
template <typename T>
|
||||
class string
|
||||
{
|
||||
public:
|
||||
|
||||
typedef T char_type;
|
||||
|
||||
//! Default constructor
|
||||
string()
|
||||
{}
|
||||
|
||||
{
|
||||
}
|
||||
|
||||
//! Copy constructor
|
||||
string(const string<T> &other)
|
||||
@ -84,7 +81,6 @@ public:
|
||||
*this = other;
|
||||
}
|
||||
|
||||
|
||||
//! Constructs a string from a float
|
||||
explicit string(const double number)
|
||||
{
|
||||
@ -93,35 +89,30 @@ public:
|
||||
str = tmpbuf;
|
||||
}
|
||||
|
||||
|
||||
//! Constructs a string from an int
|
||||
explicit string(int number)
|
||||
{
|
||||
str = std::to_string(number);
|
||||
}
|
||||
|
||||
|
||||
//! Constructs a string from an unsigned int
|
||||
explicit string(unsigned int number)
|
||||
{
|
||||
str = std::to_string(number);
|
||||
}
|
||||
|
||||
|
||||
//! Constructs a string from a long
|
||||
explicit string(long number)
|
||||
{
|
||||
str = std::to_string(number);
|
||||
}
|
||||
|
||||
|
||||
//! Constructs a string from an unsigned long
|
||||
explicit string(unsigned long number)
|
||||
{
|
||||
str = std::to_string(number);
|
||||
}
|
||||
|
||||
|
||||
//! Constructor for copying a string from a pointer with a given length
|
||||
template <class B>
|
||||
string(const B *const c, u32 length)
|
||||
@ -134,7 +125,6 @@ public:
|
||||
str[l] = (T)c[l];
|
||||
}
|
||||
|
||||
|
||||
//! Constructor for Unicode and ASCII strings
|
||||
template <class B>
|
||||
string(const B *const c)
|
||||
@ -142,11 +132,10 @@ public:
|
||||
*this = c;
|
||||
}
|
||||
|
||||
|
||||
//! Destructor
|
||||
~string()
|
||||
{}
|
||||
|
||||
{
|
||||
}
|
||||
|
||||
//! Assignment operator
|
||||
string<T> &operator=(const string<T> &other)
|
||||
@ -166,13 +155,11 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Assignment operator for strings, ASCII and Unicode
|
||||
template <class B>
|
||||
string<T> &operator=(const B *const c)
|
||||
{
|
||||
if (!c)
|
||||
{
|
||||
if (!c) {
|
||||
clear();
|
||||
return *this;
|
||||
}
|
||||
@ -188,7 +175,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Append operator for other strings
|
||||
string<T> operator+(const string<T> &other) const
|
||||
{
|
||||
@ -198,7 +184,6 @@ public:
|
||||
return tmp;
|
||||
}
|
||||
|
||||
|
||||
//! Append operator for strings, ASCII and Unicode
|
||||
template <class B>
|
||||
string<T> operator+(const B *const c) const
|
||||
@ -209,21 +194,18 @@ public:
|
||||
return tmp;
|
||||
}
|
||||
|
||||
|
||||
//! Direct access operator
|
||||
T &operator[](const u32 index)
|
||||
{
|
||||
return str[index];
|
||||
}
|
||||
|
||||
|
||||
//! Direct access operator
|
||||
const T &operator[](const u32 index) const
|
||||
{
|
||||
return str[index];
|
||||
}
|
||||
|
||||
|
||||
//! Equality operator
|
||||
bool operator==(const T *const other) const
|
||||
{
|
||||
@ -232,35 +214,30 @@ public:
|
||||
return !cmp(c_str(), other);
|
||||
}
|
||||
|
||||
|
||||
//! Equality operator
|
||||
bool operator==(const string<T> &other) const
|
||||
{
|
||||
return str == other.str;
|
||||
}
|
||||
|
||||
|
||||
//! Is smaller comparator
|
||||
bool operator<(const string<T> &other) const
|
||||
{
|
||||
return str < other.str;
|
||||
}
|
||||
|
||||
|
||||
//! Inequality operator
|
||||
bool operator!=(const T *const other) const
|
||||
{
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
|
||||
//! Inequality operator
|
||||
bool operator!=(const string<T> &other) const
|
||||
{
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
|
||||
//! Returns length of the string's content
|
||||
/** \return Length of the string's content in characters, excluding
|
||||
the trailing NUL. */
|
||||
@ -293,7 +270,6 @@ public:
|
||||
return str.c_str();
|
||||
}
|
||||
|
||||
|
||||
//! Makes the string lower case.
|
||||
string<T> &make_lower()
|
||||
{
|
||||
@ -303,7 +279,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Makes the string upper case.
|
||||
string<T> &make_upper()
|
||||
{
|
||||
@ -313,7 +288,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Compares the strings ignoring case.
|
||||
/** \param other: Other string to compare.
|
||||
\return True if the strings are equal ignoring case. */
|
||||
@ -345,15 +319,13 @@ public:
|
||||
return array[sourcePos + i] == 0 && other[i] == 0;
|
||||
}
|
||||
|
||||
|
||||
//! Compares the strings ignoring case.
|
||||
/** \param other: Other string to compare.
|
||||
\return True if this string is smaller ignoring case. */
|
||||
bool lower_ignore_case(const string<T> &other) const
|
||||
{
|
||||
const T *array = c_str();
|
||||
for(u32 i=0; array[i] && other[i]; ++i)
|
||||
{
|
||||
for (u32 i = 0; array[i] && other[i]; ++i) {
|
||||
s32 diff = (s32)locale_lower(array[i]) - (s32)locale_lower(other[i]);
|
||||
if (diff)
|
||||
return diff < 0;
|
||||
@ -362,7 +334,6 @@ public:
|
||||
return size() < other.size();
|
||||
}
|
||||
|
||||
|
||||
//! compares the first n characters of the strings
|
||||
/** \param other Other string to compare.
|
||||
\param n Number of characters to compare
|
||||
@ -380,7 +351,6 @@ public:
|
||||
return (i == n) || (size() == other.size());
|
||||
}
|
||||
|
||||
|
||||
//! compares the first n characters of the strings
|
||||
/** \param str Other string to compare.
|
||||
\param n Number of characters to compare
|
||||
@ -400,7 +370,6 @@ public:
|
||||
return (i == n) || (array[i] == 0 && other[i] == 0);
|
||||
}
|
||||
|
||||
|
||||
//! Appends a character to this string
|
||||
/** \param character: Character to append. */
|
||||
string<T> &append(T character)
|
||||
@ -409,7 +378,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a char string to this string
|
||||
/** \param other: Char string to append. */
|
||||
/** \param length: The length of the string to append. */
|
||||
@ -426,7 +394,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a string to this string
|
||||
/** \param other: String to append. */
|
||||
string<T> &append(const string<T> &other)
|
||||
@ -435,7 +402,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a string of the length l to this string.
|
||||
/** \param other: other String to append to this string.
|
||||
\param length: How much characters of the other string to add to this one. */
|
||||
@ -454,8 +420,7 @@ public:
|
||||
//\param n Number of characters from string s to use.
|
||||
string<T> &insert(u32 pos, const T *s, u32 n)
|
||||
{
|
||||
if ( pos < size()+1 )
|
||||
{
|
||||
if (pos < size() + 1) {
|
||||
str.insert(pos, s, n);
|
||||
}
|
||||
|
||||
@ -472,7 +437,6 @@ public:
|
||||
str.reserve(count - 1);
|
||||
}
|
||||
|
||||
|
||||
//! finds first occurrence of character in string
|
||||
/** \param c: Character to search for.
|
||||
\return Position where the character has been found,
|
||||
@ -499,7 +463,6 @@ public:
|
||||
return pos_from_stl(r);
|
||||
}
|
||||
|
||||
|
||||
//! Finds first position of a character not in a given list.
|
||||
/** \param c: List of characters not to find. For example if the method
|
||||
should find the first occurrence of a character not 'a' or 'b', this parameter should be "ab".
|
||||
@ -543,7 +506,6 @@ public:
|
||||
return pos_from_stl(r);
|
||||
}
|
||||
|
||||
|
||||
//! finds last occurrence of character in string
|
||||
/** \param c: Character to search for.
|
||||
\param start: start to search reverse ( default = -1, on end )
|
||||
@ -571,7 +533,6 @@ public:
|
||||
return pos_from_stl(r);
|
||||
}
|
||||
|
||||
|
||||
//! finds another string in this string
|
||||
/** \param str: Another string
|
||||
\param start: Start position of the search
|
||||
@ -579,8 +540,7 @@ public:
|
||||
or -1 if not found. */
|
||||
s32 find(const T *const other, const u32 start = 0) const
|
||||
{
|
||||
if (other && *other)
|
||||
{
|
||||
if (other && *other) {
|
||||
auto r = str.find(other, start);
|
||||
return pos_from_stl(r);
|
||||
}
|
||||
@ -588,7 +548,6 @@ public:
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
//! Returns a substring
|
||||
/** \param begin Start of substring.
|
||||
\param length Length of substring.
|
||||
@ -606,7 +565,6 @@ public:
|
||||
return o;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a character to this string
|
||||
/** \param c Character to append. */
|
||||
string<T> &operator+=(T c)
|
||||
@ -615,7 +573,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a char string to this string
|
||||
/** \param c Char string to append. */
|
||||
string<T> &operator+=(const T *const c)
|
||||
@ -624,7 +581,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a string to this string
|
||||
/** \param other String to append. */
|
||||
string<T> &operator+=(const string<T> &other)
|
||||
@ -633,7 +589,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a string representation of a number to this string
|
||||
/** \param i Number to append. */
|
||||
string<T> &operator+=(const int i)
|
||||
@ -642,7 +597,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a string representation of a number to this string
|
||||
/** \param i Number to append. */
|
||||
string<T> &operator+=(const unsigned int i)
|
||||
@ -651,7 +605,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a string representation of a number to this string
|
||||
/** \param i Number to append. */
|
||||
string<T> &operator+=(const long i)
|
||||
@ -660,7 +613,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a string representation of a number to this string
|
||||
/** \param i Number to append. */
|
||||
string<T> &operator+=(const unsigned long i)
|
||||
@ -669,7 +621,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a string representation of a number to this string
|
||||
/** \param i Number to append. */
|
||||
string<T> &operator+=(const double i)
|
||||
@ -678,7 +629,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Appends a string representation of a number to this string
|
||||
/** \param i Number to append. */
|
||||
string<T> &operator+=(const float i)
|
||||
@ -687,7 +637,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Replaces all characters of a special type with another one
|
||||
/** \param toReplace Character to replace.
|
||||
\param replaceWith Character replacing the old one. */
|
||||
@ -697,7 +646,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Replaces all instances of a string with another one.
|
||||
/** \param toReplace The string to replace.
|
||||
\param replaceWith The string replacing the old one. */
|
||||
@ -712,7 +660,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Removes a character from a string.
|
||||
/** \param c: Character to remove. */
|
||||
string<T> &remove(T c)
|
||||
@ -721,7 +668,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Removes a string from the string.
|
||||
/** \param toRemove: String to remove. */
|
||||
string<T> &remove(const string<T> &toRemove)
|
||||
@ -731,17 +677,14 @@ public:
|
||||
return *this;
|
||||
u32 pos = 0;
|
||||
u32 found = 0;
|
||||
for (u32 i=0; i<str.size(); ++i)
|
||||
{
|
||||
for (u32 i = 0; i < str.size(); ++i) {
|
||||
u32 j = 0;
|
||||
while (j < size)
|
||||
{
|
||||
while (j < size) {
|
||||
if (str[i + j] != toRemove[j])
|
||||
break;
|
||||
++j;
|
||||
}
|
||||
if (j == size)
|
||||
{
|
||||
if (j == size) {
|
||||
found += size;
|
||||
i += size - 1;
|
||||
continue;
|
||||
@ -753,7 +696,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Removes characters from a string.
|
||||
/** \param characters: Characters to remove. */
|
||||
string<T> &removeChars(const string<T> &characters)
|
||||
@ -766,7 +708,6 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Trims the string.
|
||||
/** Removes the specified characters (by default, Latin-1 whitespace)
|
||||
from the beginning and the end of the string. */
|
||||
@ -837,18 +778,14 @@ public:
|
||||
const u32 oldSize = static_cast<u32>(ret.size());
|
||||
|
||||
u32 tokenStartIdx = 0;
|
||||
for (u32 i=0; i<size()+1; ++i)
|
||||
{
|
||||
for (u32 j=0; j<countDelimiters; ++j)
|
||||
{
|
||||
if (str[i] == delimiter[j])
|
||||
{
|
||||
for (u32 i = 0; i < size() + 1; ++i) {
|
||||
for (u32 j = 0; j < countDelimiters; ++j) {
|
||||
if (str[i] == delimiter[j]) {
|
||||
if (i - tokenStartIdx > 0)
|
||||
ret.push_back(string<T>(&str[tokenStartIdx], i - tokenStartIdx));
|
||||
else if (!ignoreEmptyTokens)
|
||||
ret.push_back(string<T>());
|
||||
if ( keepSeparators )
|
||||
{
|
||||
if (keepSeparators) {
|
||||
ret.push_back(string<T>(&str[i], 1));
|
||||
}
|
||||
|
||||
@ -872,56 +809,64 @@ public:
|
||||
friend size_t wStringToUTF8(stringc &destination, const wchar_t *source);
|
||||
|
||||
private:
|
||||
|
||||
typedef std::basic_string<T> stl_type;
|
||||
|
||||
//! Private constructor
|
||||
string(stl_type &&str) : str(str)
|
||||
{}
|
||||
string(stl_type &&str) :
|
||||
str(str)
|
||||
{
|
||||
}
|
||||
|
||||
//! strlen wrapper
|
||||
template <typename U>
|
||||
static inline u32 calclen(const U* p) {
|
||||
static inline u32 calclen(const U *p)
|
||||
{
|
||||
u32 len = 0;
|
||||
while (*p++)
|
||||
len++;
|
||||
return len;
|
||||
}
|
||||
static inline u32 calclen(const char* p) {
|
||||
static inline u32 calclen(const char *p)
|
||||
{
|
||||
return static_cast<u32>(strlen(p));
|
||||
}
|
||||
static inline u32 calclen(const wchar_t* p) {
|
||||
static inline u32 calclen(const wchar_t *p)
|
||||
{
|
||||
return static_cast<u32>(wcslen(p));
|
||||
}
|
||||
|
||||
//! strcmp wrapper
|
||||
template <typename U>
|
||||
static inline int cmp(const U* p, const U* p2) {
|
||||
static inline int cmp(const U *p, const U *p2)
|
||||
{
|
||||
while (*p && *p == *p2)
|
||||
p++, p2++;
|
||||
return (int)*p - (int)*p2;
|
||||
}
|
||||
static inline int cmp(const char* p, const char* p2) {
|
||||
static inline int cmp(const char *p, const char *p2)
|
||||
{
|
||||
return strcmp(p, p2);
|
||||
}
|
||||
static inline int cmp(const wchar_t* p, const wchar_t* p2) {
|
||||
static inline int cmp(const wchar_t *p, const wchar_t *p2)
|
||||
{
|
||||
return wcscmp(p, p2);
|
||||
}
|
||||
|
||||
typedef typename stl_type::size_type size_type;
|
||||
static const size_type npos = stl_type::npos;
|
||||
|
||||
static inline s32 pos_from_stl(size_type pos) {
|
||||
static inline s32 pos_from_stl(size_type pos)
|
||||
{
|
||||
return pos == npos ? -1 : (s32)pos;
|
||||
}
|
||||
static inline size_type pos_to_stl(s32 pos) {
|
||||
static inline size_type pos_to_stl(s32 pos)
|
||||
{
|
||||
return pos == -1 ? npos : (size_type)pos;
|
||||
}
|
||||
|
||||
stl_type str;
|
||||
};
|
||||
|
||||
|
||||
//! Convert multibyte string to wide-character string
|
||||
/** Wrapper around mbstowcs from standard library, but directly using Irrlicht string class.
|
||||
What the function does exactly depends on the LC_CTYPE of the current c locale.
|
||||
@ -934,8 +879,7 @@ inline size_t multibyteToWString(stringw& destination, const core::stringc& sour
|
||||
{
|
||||
u32 sourceSize = source.size();
|
||||
|
||||
if ( sourceSize )
|
||||
{
|
||||
if (sourceSize) {
|
||||
destination.str.resize(sourceSize + 1);
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning(push)
|
||||
@ -945,26 +889,20 @@ inline size_t multibyteToWString(stringw& destination, const core::stringc& sour
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
if ( written != (size_t)-1 )
|
||||
{
|
||||
if (written != (size_t)-1) {
|
||||
destination.str.resize(written);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// Likely character which got converted until the invalid character was encountered are in destination now.
|
||||
// And it seems even 0-terminated, but I found no documentation anywhere that this (the 0-termination) is guaranteed :-(
|
||||
destination.clear();
|
||||
}
|
||||
return written;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
destination.clear();
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline size_t utf8ToWString(stringw &destination, const char *source)
|
||||
{
|
||||
std::wstring_convert<std::codecvt_utf8<wchar_t>> conv;
|
||||
@ -989,8 +927,5 @@ inline size_t wStringToUTF8(stringc &destination, const stringw &source)
|
||||
return wStringToUTF8(destination, source.c_str());
|
||||
}
|
||||
|
||||
|
||||
} // end namespace core
|
||||
} // end namespace irr
|
||||
|
||||
|
||||
|
@ -19,31 +19,24 @@ typedef int8_t s8;
|
||||
/** This is a typedef for char, it ensures portability of the engine. */
|
||||
typedef char c8;
|
||||
|
||||
|
||||
|
||||
//! 16 bit unsigned variable.
|
||||
typedef uint16_t u16;
|
||||
|
||||
//! 16 bit signed variable.
|
||||
typedef int16_t s16;
|
||||
|
||||
|
||||
|
||||
//! 32 bit unsigned variable.
|
||||
typedef uint32_t u32;
|
||||
|
||||
//! 32 bit signed variable.
|
||||
typedef int32_t s32;
|
||||
|
||||
|
||||
//! 64 bit unsigned variable.
|
||||
typedef uint64_t u64;
|
||||
|
||||
//! 64 bit signed variable.
|
||||
typedef int64_t s64;
|
||||
|
||||
|
||||
|
||||
//! 32 bit floating point variable.
|
||||
/** This is a typedef for float, it ensures portability of the engine. */
|
||||
typedef float f32;
|
||||
@ -52,10 +45,8 @@ typedef float f32;
|
||||
/** This is a typedef for double, it ensures portability of the engine. */
|
||||
typedef double f64;
|
||||
|
||||
|
||||
} // end namespace irr
|
||||
|
||||
|
||||
//! Defines for snprintf_irr because snprintf method does not match the ISO C
|
||||
//! standard on Windows platforms.
|
||||
//! We want int snprintf_irr(char *str, size_t size, const char *format, ...);
|
||||
@ -78,7 +69,10 @@ namespace irr
|
||||
#if defined(_DEBUG)
|
||||
#if defined(_IRR_WINDOWS_API_) && defined(_MSC_VER)
|
||||
#include <crtdbg.h>
|
||||
#define _IRR_DEBUG_BREAK_IF( _CONDITION_ ) if (_CONDITION_) {_CrtDbgBreak();}
|
||||
#define _IRR_DEBUG_BREAK_IF(_CONDITION_) \
|
||||
if (_CONDITION_) { \
|
||||
_CrtDbgBreak(); \
|
||||
}
|
||||
#else
|
||||
#include <assert.h>
|
||||
#define _IRR_DEBUG_BREAK_IF(_CONDITION_) assert(!(_CONDITION_));
|
||||
@ -97,4 +91,3 @@ code like 'code', but some generate warnings so we use this macro here */
|
||||
#define MAKE_IRR_ID(c0, c1, c2, c3) \
|
||||
((irr::u32)(irr::u8)(c0) | ((irr::u32)(irr::u8)(c1) << 8) | \
|
||||
((irr::u32)(irr::u8)(c2) << 16) | ((irr::u32)(irr::u8)(c3) << 24))
|
||||
|
||||
|
@ -273,7 +273,6 @@ namespace irr
|
||||
bool vsync = false,
|
||||
IEventReceiver *receiver = 0);
|
||||
|
||||
|
||||
//! Creates an Irrlicht device with the option to specify advanced parameters.
|
||||
/** Usually you should used createDevice() for creating an Irrlicht Engine device.
|
||||
Use this function only if you wish to specify advanced parameters like a window
|
||||
|
@ -23,4 +23,3 @@
|
||||
#else
|
||||
#error compiler not supported
|
||||
#endif
|
||||
|
||||
|
@ -11,4 +11,3 @@
|
||||
#endif
|
||||
|
||||
#undef PACK_STRUCT
|
||||
|
||||
|
107
include/line2d.h
107
include/line2d.h
@ -18,32 +18,61 @@ class line2d
|
||||
{
|
||||
public:
|
||||
//! Default constructor for line going from (0,0) to (1,1).
|
||||
constexpr line2d() : start(0,0), end(1,1) {}
|
||||
constexpr line2d() :
|
||||
start(0, 0), end(1, 1) {}
|
||||
//! Constructor for line between the two points.
|
||||
constexpr line2d(T xa, T ya, T xb, T yb) : start(xa, ya), end(xb, yb) {}
|
||||
constexpr line2d(T xa, T ya, T xb, T yb) :
|
||||
start(xa, ya), end(xb, yb) {}
|
||||
//! Constructor for line between the two points given as vectors.
|
||||
constexpr line2d(const vector2d<T>& start, const vector2d<T>& end) : start(start), end(end) {}
|
||||
constexpr line2d(const vector2d<T> &start, const vector2d<T> &end) :
|
||||
start(start), end(end) {}
|
||||
|
||||
// operators
|
||||
|
||||
line2d<T> operator+(const vector2d<T> &point) const { return line2d<T>(start + point, end + point); }
|
||||
line2d<T>& operator+=(const vector2d<T>& point) { start += point; end += point; return *this; }
|
||||
line2d<T> &operator+=(const vector2d<T> &point)
|
||||
{
|
||||
start += point;
|
||||
end += point;
|
||||
return *this;
|
||||
}
|
||||
|
||||
line2d<T> operator-(const vector2d<T> &point) const { return line2d<T>(start - point, end - point); }
|
||||
line2d<T>& operator-=(const vector2d<T>& point) { start -= point; end -= point; return *this; }
|
||||
line2d<T> &operator-=(const vector2d<T> &point)
|
||||
{
|
||||
start -= point;
|
||||
end -= point;
|
||||
return *this;
|
||||
}
|
||||
|
||||
constexpr bool operator==(const line2d<T> &other) const
|
||||
{ return (start==other.start && end==other.end) || (end==other.start && start==other.end);}
|
||||
{
|
||||
return (start == other.start && end == other.end) || (end == other.start && start == other.end);
|
||||
}
|
||||
constexpr bool operator!=(const line2d<T> &other) const
|
||||
{ return !(start==other.start && end==other.end) || (end==other.start && start==other.end);}
|
||||
{
|
||||
return !(start == other.start && end == other.end) || (end == other.start && start == other.end);
|
||||
}
|
||||
|
||||
// functions
|
||||
//! Set this line to new line going through the two points.
|
||||
void setLine(const T& xa, const T& ya, const T& xb, const T& yb){start.set(xa, ya); end.set(xb, yb);}
|
||||
void setLine(const T &xa, const T &ya, const T &xb, const T &yb)
|
||||
{
|
||||
start.set(xa, ya);
|
||||
end.set(xb, yb);
|
||||
}
|
||||
//! Set this line to new line going through the two points.
|
||||
void setLine(const vector2d<T>& nstart, const vector2d<T>& nend){start.set(nstart); end.set(nend);}
|
||||
void setLine(const vector2d<T> &nstart, const vector2d<T> &nend)
|
||||
{
|
||||
start.set(nstart);
|
||||
end.set(nend);
|
||||
}
|
||||
//! Set this line to new line given as parameter.
|
||||
void setLine(const line2d<T>& line){start.set(line.start); end.set(line.end);}
|
||||
void setLine(const line2d<T> &line)
|
||||
{
|
||||
start.set(line.start);
|
||||
end.set(line.end);
|
||||
}
|
||||
|
||||
//! Get length of line
|
||||
/** \return Length of the line. */
|
||||
@ -83,10 +112,14 @@ class line2d
|
||||
return true;
|
||||
|
||||
// Special Cases to check if segments are colinear
|
||||
if (o1 == 0 && other.start.isBetweenPoints( start, end)) return true;
|
||||
if (o2 == 0 && other.end.isBetweenPoints( start, end)) return true;
|
||||
if (o3 == 0 && start.isBetweenPoints( other.start, other.end)) return true;
|
||||
if (o4 == 0 && end.isBetweenPoints( other.start, other.end)) return true;
|
||||
if (o1 == 0 && other.start.isBetweenPoints(start, end))
|
||||
return true;
|
||||
if (o2 == 0 && other.end.isBetweenPoints(start, end))
|
||||
return true;
|
||||
if (o3 == 0 && start.isBetweenPoints(other.start, other.end))
|
||||
return true;
|
||||
if (o4 == 0 && end.isBetweenPoints(other.start, other.end))
|
||||
return true;
|
||||
|
||||
return false; // Doesn't fall in any of the above cases
|
||||
}
|
||||
@ -94,9 +127,7 @@ class line2d
|
||||
/*! Check if 2 segments are incident (intersects in exactly 1 point).*/
|
||||
bool incidentSegments(const line2d<T> &other) const
|
||||
{
|
||||
return
|
||||
start.checkOrientation( end, other.start) != start.checkOrientation( end, other.end)
|
||||
&& other.start.checkOrientation( other.end, start) != other.start.checkOrientation( other.end, end);
|
||||
return start.checkOrientation(end, other.start) != start.checkOrientation(end, other.end) && other.start.checkOrientation(other.end, start) != other.start.checkOrientation(other.end, end);
|
||||
}
|
||||
|
||||
/*! Check if 2 lines/segments are parallel or nearly parallel.*/
|
||||
@ -117,8 +148,7 @@ class line2d
|
||||
const f32 commonDenominator = (f32)((l.end.Y - l.start.Y) * (end.X - start.X) -
|
||||
(l.end.X - l.start.X) * (end.Y - start.Y));
|
||||
|
||||
if ( commonDenominator != 0.f )
|
||||
{
|
||||
if (commonDenominator != 0.f) {
|
||||
const f32 numeratorA = (f32)((l.end.X - l.start.X) * (start.Y - l.start.Y) -
|
||||
(l.end.Y - l.start.Y) * (start.X - l.start.X));
|
||||
|
||||
@ -127,10 +157,8 @@ class line2d
|
||||
// Calculate the intersection point.
|
||||
return vector2d<T>(
|
||||
(T)(start.X + uA * (end.X - start.X)),
|
||||
(T)(start.Y + uA * (end.Y - start.Y))
|
||||
);
|
||||
}
|
||||
else
|
||||
(T)(start.Y + uA * (end.Y - start.Y)));
|
||||
} else
|
||||
return l.start;
|
||||
}
|
||||
|
||||
@ -167,12 +195,10 @@ class line2d
|
||||
const f32 numeratorB = (f32)((end.X - start.X) * (start.Y - l.start.Y) -
|
||||
(end.Y - start.Y) * (start.X - l.start.X));
|
||||
|
||||
if(equals(commonDenominator, 0.f))
|
||||
{
|
||||
if (equals(commonDenominator, 0.f)) {
|
||||
// The lines are either coincident or parallel
|
||||
// if both numerators are 0, the lines are coincident
|
||||
if(!ignoreCoincidentLines && equals(numeratorA, 0.f) && equals(numeratorB, 0.f))
|
||||
{
|
||||
if (!ignoreCoincidentLines && equals(numeratorA, 0.f) && equals(numeratorB, 0.f)) {
|
||||
// Try and find a common endpoint
|
||||
if (l.start == start || l.end == start)
|
||||
out = start;
|
||||
@ -188,8 +214,7 @@ class line2d
|
||||
else if (l.start.Y < start.Y && l.end.Y < start.Y && l.start.Y < end.Y && l.end.Y < end.Y)
|
||||
return false;
|
||||
// else the lines are overlapping to some extent
|
||||
else
|
||||
{
|
||||
else {
|
||||
// find the points which are not contributing to the
|
||||
// common part
|
||||
vector2d<T> maxp;
|
||||
@ -235,8 +260,7 @@ class line2d
|
||||
// Get the point of intersection on this line, checking that
|
||||
// it is within the line segment.
|
||||
const f32 uA = numeratorA / commonDenominator;
|
||||
if (checkOnlySegments)
|
||||
{
|
||||
if (checkOnlySegments) {
|
||||
if (uA < 0.f || uA > 1.f)
|
||||
return false; // Outside the line segment
|
||||
|
||||
@ -307,10 +331,11 @@ class line2d
|
||||
v /= d;
|
||||
f64 t = v.dotProduct(c);
|
||||
|
||||
if ( checkOnlySegments )
|
||||
{
|
||||
if (t < 0) return vector2d<T>((T)start.X, (T)start.Y);
|
||||
if (t > d) return vector2d<T>((T)end.X, (T)end.Y);
|
||||
if (checkOnlySegments) {
|
||||
if (t < 0)
|
||||
return vector2d<T>((T)start.X, (T)start.Y);
|
||||
if (t > d)
|
||||
return vector2d<T>((T)end.X, (T)end.Y);
|
||||
}
|
||||
|
||||
v *= t;
|
||||
@ -335,17 +360,17 @@ class line2d
|
||||
v /= d;
|
||||
const f32 t = v.dotProduct(c);
|
||||
|
||||
if ( checkOnlySegments )
|
||||
{
|
||||
if (t < 0) return start;
|
||||
if (t > d) return end;
|
||||
if (checkOnlySegments) {
|
||||
if (t < 0)
|
||||
return start;
|
||||
if (t > d)
|
||||
return end;
|
||||
}
|
||||
|
||||
v *= t;
|
||||
return start + v;
|
||||
}
|
||||
|
||||
|
||||
//! Typedef for an f32 line.
|
||||
typedef line2d<f32> line2df;
|
||||
//! Typedef for an integer line.
|
||||
@ -353,5 +378,3 @@ class line2d
|
||||
|
||||
} // end namespace core
|
||||
} // end namespace irr
|
||||
|
||||
|
||||
|
@ -17,38 +17,63 @@ template <class T>
|
||||
class line3d
|
||||
{
|
||||
public:
|
||||
|
||||
//! Default constructor
|
||||
/** line from (0,0,0) to (1,1,1) */
|
||||
constexpr line3d() : start(0,0,0), end(1,1,1) {}
|
||||
constexpr line3d() :
|
||||
start(0, 0, 0), end(1, 1, 1) {}
|
||||
//! Constructor with two points
|
||||
constexpr line3d(T xa, T ya, T za, T xb, T yb, T zb) : start(xa, ya, za), end(xb, yb, zb) {}
|
||||
constexpr line3d(T xa, T ya, T za, T xb, T yb, T zb) :
|
||||
start(xa, ya, za), end(xb, yb, zb) {}
|
||||
//! Constructor with two points as vectors
|
||||
constexpr line3d(const vector3d<T>& start, const vector3d<T>& end) : start(start), end(end) {}
|
||||
constexpr line3d(const vector3d<T> &start, const vector3d<T> &end) :
|
||||
start(start), end(end) {}
|
||||
|
||||
// operators
|
||||
|
||||
line3d<T> operator+(const vector3d<T> &point) const { return line3d<T>(start + point, end + point); }
|
||||
line3d<T>& operator+=(const vector3d<T>& point) { start += point; end += point; return *this; }
|
||||
line3d<T> &operator+=(const vector3d<T> &point)
|
||||
{
|
||||
start += point;
|
||||
end += point;
|
||||
return *this;
|
||||
}
|
||||
|
||||
line3d<T> operator-(const vector3d<T> &point) const { return line3d<T>(start - point, end - point); }
|
||||
line3d<T>& operator-=(const vector3d<T>& point) { start -= point; end -= point; return *this; }
|
||||
line3d<T> &operator-=(const vector3d<T> &point)
|
||||
{
|
||||
start -= point;
|
||||
end -= point;
|
||||
return *this;
|
||||
}
|
||||
|
||||
constexpr bool operator==(const line3d<T> &other) const
|
||||
{ return (start==other.start && end==other.end) || (end==other.start && start==other.end);}
|
||||
{
|
||||
return (start == other.start && end == other.end) || (end == other.start && start == other.end);
|
||||
}
|
||||
constexpr bool operator!=(const line3d<T> &other) const
|
||||
{ return !(start==other.start && end==other.end) || (end==other.start && start==other.end);}
|
||||
{
|
||||
return !(start == other.start && end == other.end) || (end == other.start && start == other.end);
|
||||
}
|
||||
|
||||
// functions
|
||||
//! Set this line to a new line going through the two points.
|
||||
void setLine(const T &xa, const T &ya, const T &za, const T &xb, const T &yb, const T &zb)
|
||||
{start.set(xa, ya, za); end.set(xb, yb, zb);}
|
||||
{
|
||||
start.set(xa, ya, za);
|
||||
end.set(xb, yb, zb);
|
||||
}
|
||||
//! Set this line to a new line going through the two points.
|
||||
void setLine(const vector3d<T> &nstart, const vector3d<T> &nend)
|
||||
{start.set(nstart); end.set(nend);}
|
||||
{
|
||||
start.set(nstart);
|
||||
end.set(nend);
|
||||
}
|
||||
//! Set this line to new line given as parameter.
|
||||
void setLine(const line3d<T> &line)
|
||||
{start.set(line.start); end.set(line.end);}
|
||||
{
|
||||
start.set(line.start);
|
||||
end.set(line.end);
|
||||
}
|
||||
|
||||
//! Get length of line
|
||||
/** \return Length of line. */
|
||||
@ -138,5 +163,3 @@ class line3d
|
||||
|
||||
} // end namespace core
|
||||
} // end namespace irr
|
||||
|
||||
|
||||
|
@ -29,7 +29,6 @@ namespace core
|
||||
class CMatrix4
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor Flags
|
||||
enum eConstructor
|
||||
{
|
||||
@ -51,10 +50,22 @@ namespace core
|
||||
const T &r2c0, const T &r2c1, const T &r2c2, const T &r2c3,
|
||||
const T &r3c0, const T &r3c1, const T &r3c2, const T &r3c3)
|
||||
{
|
||||
M[0] = r0c0; M[1] = r0c1; M[2] = r0c2; M[3] = r0c3;
|
||||
M[4] = r1c0; M[5] = r1c1; M[6] = r1c2; M[7] = r1c3;
|
||||
M[8] = r2c0; M[9] = r2c1; M[10] = r2c2; M[11] = r2c3;
|
||||
M[12] = r3c0; M[13] = r3c1; M[14] = r3c2; M[15] = r3c3;
|
||||
M[0] = r0c0;
|
||||
M[1] = r0c1;
|
||||
M[2] = r0c2;
|
||||
M[3] = r0c3;
|
||||
M[4] = r1c0;
|
||||
M[5] = r1c1;
|
||||
M[6] = r1c2;
|
||||
M[7] = r1c3;
|
||||
M[8] = r2c0;
|
||||
M[9] = r2c1;
|
||||
M[10] = r2c2;
|
||||
M[11] = r2c3;
|
||||
M[12] = r3c0;
|
||||
M[13] = r3c1;
|
||||
M[14] = r3c2;
|
||||
M[15] = r3c3;
|
||||
}
|
||||
|
||||
//! Copy constructor
|
||||
@ -284,7 +295,6 @@ namespace core
|
||||
/** \return Returns false if there is no inverse matrix.*/
|
||||
bool makeInverse();
|
||||
|
||||
|
||||
//! Inverts a primitive matrix which only contains a translation and a rotation
|
||||
/** \param out: where result matrix is written to. */
|
||||
bool getInversePrimitive(CMatrix4<T> &out) const;
|
||||
@ -450,18 +460,17 @@ namespace core
|
||||
//! Flag is this matrix is identity matrix
|
||||
mutable u32 definitelyIdentityMatrix;
|
||||
#endif
|
||||
|
||||
};
|
||||
|
||||
// Default constructor
|
||||
template <class T>
|
||||
inline CMatrix4<T>::CMatrix4(eConstructor constructor)
|
||||
#if defined(USE_MATRIX_TEST)
|
||||
: definitelyIdentityMatrix(BIT_UNTESTED)
|
||||
:
|
||||
definitelyIdentityMatrix(BIT_UNTESTED)
|
||||
#endif
|
||||
{
|
||||
switch ( constructor )
|
||||
{
|
||||
switch (constructor) {
|
||||
case EM4CONST_NOTHING:
|
||||
case EM4CONST_COPY:
|
||||
break;
|
||||
@ -477,11 +486,11 @@ namespace core
|
||||
template <class T>
|
||||
inline CMatrix4<T>::CMatrix4(const CMatrix4<T> &other, eConstructor constructor)
|
||||
#if defined(USE_MATRIX_TEST)
|
||||
: definitelyIdentityMatrix(BIT_UNTESTED)
|
||||
:
|
||||
definitelyIdentityMatrix(BIT_UNTESTED)
|
||||
#endif
|
||||
{
|
||||
switch ( constructor )
|
||||
{
|
||||
switch (constructor) {
|
||||
case EM4CONST_IDENTITY:
|
||||
makeIdentity();
|
||||
break;
|
||||
@ -662,14 +671,10 @@ namespace core
|
||||
{
|
||||
#if defined(USE_MATRIX_TEST)
|
||||
// do checks on your own in order to avoid copy creation
|
||||
if ( !other.isIdentity() )
|
||||
{
|
||||
if ( this->isIdentity() )
|
||||
{
|
||||
if (!other.isIdentity()) {
|
||||
if (this->isIdentity()) {
|
||||
return (*this = other);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
CMatrix4<T> temp(*this);
|
||||
return setbyproduct_nocheck(temp, other);
|
||||
}
|
||||
@ -715,7 +720,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! multiply by another matrix
|
||||
// set this matrix to the product of two other matrices
|
||||
// goal is to reduce stack use and copy
|
||||
@ -725,8 +729,7 @@ namespace core
|
||||
#if defined(USE_MATRIX_TEST)
|
||||
if (other_a.isIdentity())
|
||||
return (*this = other_b);
|
||||
else
|
||||
if ( other_b.isIdentity () )
|
||||
else if (other_b.isIdentity())
|
||||
return (*this = other_a);
|
||||
else
|
||||
return setbyproduct_nocheck(other_a, other_b);
|
||||
@ -773,15 +776,12 @@ namespace core
|
||||
return m3;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template <class T>
|
||||
inline vector3d<T> CMatrix4<T>::getTranslation() const
|
||||
{
|
||||
return vector3d<T>(M[12], M[13], M[14]);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::setTranslation(const vector3d<T> &translation)
|
||||
{
|
||||
@ -884,7 +884,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//! Returns a rotation which (mostly) works in combination with the given scale
|
||||
/**
|
||||
This code was originally written by by Chev (assuming no scaling back then,
|
||||
@ -903,8 +902,7 @@ namespace core
|
||||
|
||||
f64 rotx, roty, X, Z;
|
||||
|
||||
if (!core::iszero((T)C))
|
||||
{
|
||||
if (!core::iszero((T)C)) {
|
||||
const f64 invC = core::reciprocal(C);
|
||||
rotx = mat[10] * invC * invScale.Z;
|
||||
roty = mat[6] * invC * invScale.Y;
|
||||
@ -912,9 +910,7 @@ namespace core
|
||||
rotx = mat[0] * invC * invScale.X;
|
||||
roty = mat[1] * invC * invScale.X;
|
||||
Z = atan2(roty, rotx) * RADTODEG64;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
X = 0.0;
|
||||
rotx = mat[5] * invScale.Y;
|
||||
roty = -mat[4] * invScale.Y;
|
||||
@ -922,9 +918,12 @@ namespace core
|
||||
}
|
||||
|
||||
// fix values that get below zero
|
||||
if (X < 0.0) X += 360.0;
|
||||
if (Y < 0.0) Y += 360.0;
|
||||
if (Z < 0.0) Z += 360.0;
|
||||
if (X < 0.0)
|
||||
X += 360.0;
|
||||
if (Y < 0.0)
|
||||
Y += 360.0;
|
||||
if (Z < 0.0)
|
||||
Z += 360.0;
|
||||
|
||||
return vector3d<T>((T)X, (T)Y, (T)Z);
|
||||
}
|
||||
@ -944,18 +943,13 @@ namespace core
|
||||
// We assume the matrix uses rotations instead of negative scaling 2 axes.
|
||||
// Otherwise it fails even for some simple cases, like rotating around
|
||||
// 2 axes by 180° which getScale thinks is a negative scaling.
|
||||
if (scale.Y<0 && scale.Z<0)
|
||||
{
|
||||
if (scale.Y < 0 && scale.Z < 0) {
|
||||
scale.Y = -scale.Y;
|
||||
scale.Z = -scale.Z;
|
||||
}
|
||||
else if (scale.X<0 && scale.Z<0)
|
||||
{
|
||||
} else if (scale.X < 0 && scale.Z < 0) {
|
||||
scale.X = -scale.X;
|
||||
scale.Z = -scale.Z;
|
||||
}
|
||||
else if (scale.X<0 && scale.Y<0)
|
||||
{
|
||||
} else if (scale.X < 0 && scale.Y < 0) {
|
||||
scale.X = -scale.X;
|
||||
scale.Y = -scale.Y;
|
||||
}
|
||||
@ -963,7 +957,6 @@ namespace core
|
||||
return getRotationDegrees(scale);
|
||||
}
|
||||
|
||||
|
||||
//! Sets matrix to rotation matrix of inverse angles given as parameters
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::setInverseRotationRadians(const vector3d<T> &rotation)
|
||||
@ -1029,7 +1022,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
/*!
|
||||
*/
|
||||
template <class T>
|
||||
@ -1043,7 +1035,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
check identity with epsilon
|
||||
solve floating range problems..
|
||||
@ -1084,7 +1075,6 @@ namespace core
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/* Check orthogonality of matrix. */
|
||||
template <class T>
|
||||
inline bool CMatrix4<T>::isOrthogonal() const
|
||||
@ -1108,7 +1098,6 @@ namespace core
|
||||
return (iszero(dp));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
doesn't solve floating range problems..
|
||||
but takes care on +/- 0 on translation because we are changing it..
|
||||
@ -1122,25 +1111,41 @@ namespace core
|
||||
if (definitelyIdentityMatrix)
|
||||
return true;
|
||||
#endif
|
||||
if(IR(M[0])!=F32_VALUE_1) return false;
|
||||
if(IR(M[1])!=0) return false;
|
||||
if(IR(M[2])!=0) return false;
|
||||
if(IR(M[3])!=0) return false;
|
||||
if (IR(M[0]) != F32_VALUE_1)
|
||||
return false;
|
||||
if (IR(M[1]) != 0)
|
||||
return false;
|
||||
if (IR(M[2]) != 0)
|
||||
return false;
|
||||
if (IR(M[3]) != 0)
|
||||
return false;
|
||||
|
||||
if(IR(M[4])!=0) return false;
|
||||
if(IR(M[5])!=F32_VALUE_1) return false;
|
||||
if(IR(M[6])!=0) return false;
|
||||
if(IR(M[7])!=0) return false;
|
||||
if (IR(M[4]) != 0)
|
||||
return false;
|
||||
if (IR(M[5]) != F32_VALUE_1)
|
||||
return false;
|
||||
if (IR(M[6]) != 0)
|
||||
return false;
|
||||
if (IR(M[7]) != 0)
|
||||
return false;
|
||||
|
||||
if(IR(M[8])!=0) return false;
|
||||
if(IR(M[9])!=0) return false;
|
||||
if(IR(M[10])!=F32_VALUE_1) return false;
|
||||
if(IR(M[11])!=0) return false;
|
||||
if (IR(M[8]) != 0)
|
||||
return false;
|
||||
if (IR(M[9]) != 0)
|
||||
return false;
|
||||
if (IR(M[10]) != F32_VALUE_1)
|
||||
return false;
|
||||
if (IR(M[11]) != 0)
|
||||
return false;
|
||||
|
||||
if(IR(M[12])!=0) return false;
|
||||
if(IR(M[13])!=0) return false;
|
||||
if(IR(M[13])!=0) return false;
|
||||
if(IR(M[15])!=F32_VALUE_1) return false;
|
||||
if (IR(M[12]) != 0)
|
||||
return false;
|
||||
if (IR(M[13]) != 0)
|
||||
return false;
|
||||
if (IR(M[13]) != 0)
|
||||
return false;
|
||||
if (IR(M[15]) != F32_VALUE_1)
|
||||
return false;
|
||||
|
||||
#if defined(USE_MATRIX_TEST)
|
||||
definitelyIdentityMatrix = true;
|
||||
@ -1148,7 +1153,6 @@ namespace core
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline void CMatrix4<T>::rotateVect(vector3df &vect) const
|
||||
{
|
||||
@ -1207,7 +1211,6 @@ namespace core
|
||||
out.Z = in.X * M[2] + in.Y * M[6] + in.Z * M[10] + M[14];
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline void CMatrix4<T>::transformVect(T *out, const core::vector3df &in) const
|
||||
{
|
||||
@ -1234,7 +1237,6 @@ namespace core
|
||||
out[3] = in[0] * M[3] + in[1] * M[7] + in[2] * M[11] + in[3] * M[15];
|
||||
}
|
||||
|
||||
|
||||
//! Transforms a plane by this matrix
|
||||
template <class T>
|
||||
inline void CMatrix4<T>::transformPlane(core::plane3d<f32> &plane) const
|
||||
@ -1279,20 +1281,15 @@ namespace core
|
||||
|
||||
const CMatrix4<T> &m = *this;
|
||||
|
||||
for (u32 i = 0; i < 3; ++i)
|
||||
{
|
||||
for (u32 j = 0; j < 3; ++j)
|
||||
{
|
||||
for (u32 i = 0; i < 3; ++i) {
|
||||
for (u32 j = 0; j < 3; ++j) {
|
||||
const f32 a = m(j, i) * Amin[j];
|
||||
const f32 b = m(j, i) * Amax[j];
|
||||
|
||||
if (a < b)
|
||||
{
|
||||
if (a < b) {
|
||||
Bmin[i] += a;
|
||||
Bmax[i] += b;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
Bmin[i] += b;
|
||||
Bmax[i] += a;
|
||||
}
|
||||
@ -1308,7 +1305,6 @@ namespace core
|
||||
box.MaxEdge.Z = Bmax[2];
|
||||
}
|
||||
|
||||
|
||||
//! Multiplies this matrix by a 1x4 matrix
|
||||
template <class T>
|
||||
inline void CMatrix4<T>::multiplyWith1x4Matrix(T *matrix) const
|
||||
@ -1348,7 +1344,6 @@ namespace core
|
||||
vect.Z = vect.Z + M[14];
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline bool CMatrix4<T>::getInverse(CMatrix4<T> &out) const
|
||||
{
|
||||
@ -1357,8 +1352,7 @@ namespace core
|
||||
/// If no inverse exists then 'false' is returned.
|
||||
|
||||
#if defined(USE_MATRIX_TEST)
|
||||
if ( this->isIdentity() )
|
||||
{
|
||||
if (this->isIdentity()) {
|
||||
out = *this;
|
||||
return true;
|
||||
}
|
||||
@ -1432,7 +1426,6 @@ namespace core
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//! Inverts a primitive matrix which only contains a translation and a rotation
|
||||
//! \param out: where result matrix is written to.
|
||||
template <class T>
|
||||
@ -1475,8 +1468,7 @@ namespace core
|
||||
#endif
|
||||
CMatrix4<T> temp(EM4CONST_NOTHING);
|
||||
|
||||
if (getInverse(temp))
|
||||
{
|
||||
if (getInverse(temp)) {
|
||||
*this = temp;
|
||||
return true;
|
||||
}
|
||||
@ -1484,7 +1476,6 @@ namespace core
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::operator=(const T &scalar)
|
||||
{
|
||||
@ -1497,7 +1488,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// Builds a right-handed perspective projection matrix based on a field of view
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::buildProjectionMatrixPerspectiveFovRH(
|
||||
@ -1532,8 +1522,7 @@ namespace core
|
||||
{
|
||||
M[10] = (T)(zFar / (zNear - zFar));
|
||||
M[14] = (T)(zNear * zFar / (zNear - zFar));
|
||||
}
|
||||
else // OpenGL version
|
||||
} else // OpenGL version
|
||||
{
|
||||
M[10] = (T)((zFar + zNear) / (zNear - zFar));
|
||||
M[14] = (T)(2.0f * zNear * zFar / (zNear - zFar));
|
||||
@ -1545,7 +1534,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// Builds a left-handed perspective projection matrix based on a field of view
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::buildProjectionMatrixPerspectiveFovLH(
|
||||
@ -1580,8 +1568,7 @@ namespace core
|
||||
{
|
||||
M[10] = (T)(zFar / (zFar - zNear));
|
||||
M[14] = (T)(-zNear * zFar / (zFar - zNear));
|
||||
}
|
||||
else // OpenGL version
|
||||
} else // OpenGL version
|
||||
{
|
||||
M[10] = (T)((zFar + zNear) / (zFar - zNear));
|
||||
M[14] = (T)(2.0f * zNear * zFar / (zNear - zFar));
|
||||
@ -1593,7 +1580,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// Builds a left-handed perspective projection matrix based on a field of view, with far plane culling at infinity
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::buildProjectionMatrixPerspectiveFovInfinityLH(
|
||||
@ -1629,7 +1615,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// Builds a left-handed orthogonal projection matrix.
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::buildProjectionMatrixOrthoLH(
|
||||
@ -1658,13 +1643,10 @@ namespace core
|
||||
// M[14]
|
||||
M[15] = 1;
|
||||
|
||||
if ( zClipFromZero )
|
||||
{
|
||||
if (zClipFromZero) {
|
||||
M[10] = (T)(1 / (zFar - zNear));
|
||||
M[14] = (T)(zNear / (zNear - zFar));
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
M[10] = (T)(2 / (zFar - zNear));
|
||||
M[14] = (T) - (zFar + zNear) / (zFar - zNear);
|
||||
}
|
||||
@ -1675,7 +1657,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// Builds a right-handed orthogonal projection matrix.
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::buildProjectionMatrixOrthoRH(
|
||||
@ -1704,13 +1685,10 @@ namespace core
|
||||
// M[14]
|
||||
M[15] = 1;
|
||||
|
||||
if ( zClipFromZero )
|
||||
{
|
||||
if (zClipFromZero) {
|
||||
M[10] = (T)(1 / (zNear - zFar));
|
||||
M[14] = (T)(zNear / (zNear - zFar));
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
M[10] = (T)(2 / (zNear - zFar));
|
||||
M[14] = (T) - (zFar + zNear) / (zFar - zNear);
|
||||
}
|
||||
@ -1721,7 +1699,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// Builds a right-handed perspective projection matrix.
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::buildProjectionMatrixPerspectiveRH(
|
||||
@ -1754,8 +1731,7 @@ namespace core
|
||||
{
|
||||
M[10] = (T)(zFar / (zNear - zFar));
|
||||
M[14] = (T)(zNear * zFar / (zNear - zFar));
|
||||
}
|
||||
else // OpenGL version
|
||||
} else // OpenGL version
|
||||
{
|
||||
M[10] = (T)((zFar + zNear) / (zNear - zFar));
|
||||
M[14] = (T)(2.0f * zNear * zFar / (zNear - zFar));
|
||||
@ -1767,7 +1743,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// Builds a left-handed perspective projection matrix.
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::buildProjectionMatrixPerspectiveLH(
|
||||
@ -1800,8 +1775,7 @@ namespace core
|
||||
{
|
||||
M[10] = (T)(zFar / (zFar - zNear));
|
||||
M[14] = (T)(zNear * zFar / (zNear - zFar));
|
||||
}
|
||||
else // OpenGL version
|
||||
} else // OpenGL version
|
||||
{
|
||||
M[10] = (T)((zFar + zNear) / (zFar - zNear));
|
||||
M[14] = (T)(2.0f * zNear * zFar / (zNear - zFar));
|
||||
@ -1813,7 +1787,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// Builds a matrix that flattens geometry into a plane.
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::buildShadowMatrix(const core::vector3df &light, core::plane3df plane, f32 point)
|
||||
@ -1886,7 +1859,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// Builds a right-handed look-at matrix.
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::buildCameraLookAtMatrixRH(
|
||||
@ -1927,15 +1899,13 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// creates a new matrix as interpolated matrix from this and the passed one.
|
||||
template <class T>
|
||||
inline CMatrix4<T> CMatrix4<T>::interpolate(const core::CMatrix4<T> &b, f32 time) const
|
||||
{
|
||||
CMatrix4<T> mat(EM4CONST_NOTHING);
|
||||
|
||||
for (u32 i=0; i < 16; i += 4)
|
||||
{
|
||||
for (u32 i = 0; i < 16; i += 4) {
|
||||
mat.M[i + 0] = (T)(M[i + 0] + (b.M[i + 0] - M[i + 0]) * time);
|
||||
mat.M[i + 1] = (T)(M[i + 1] + (b.M[i + 1] - M[i + 1]) * time);
|
||||
mat.M[i + 2] = (T)(M[i + 2] + (b.M[i + 2] - M[i + 2]) * time);
|
||||
@ -1944,7 +1914,6 @@ namespace core
|
||||
return mat;
|
||||
}
|
||||
|
||||
|
||||
// returns transposed matrix
|
||||
template <class T>
|
||||
inline CMatrix4<T> CMatrix4<T>::getTransposed() const
|
||||
@ -1954,7 +1923,6 @@ namespace core
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
// returns transposed matrix
|
||||
template <class T>
|
||||
inline void CMatrix4<T>::getTransposed(CMatrix4<T> &o) const
|
||||
@ -1983,7 +1951,6 @@ namespace core
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
// used to scale <-1,-1><1,1> to viewport
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::buildNDCToDCMatrix(const core::rect<s32> &viewport, f32 zScale)
|
||||
@ -2111,7 +2078,6 @@ namespace core
|
||||
setRotationCenter(center, translation);
|
||||
}
|
||||
|
||||
|
||||
//! Builds a combined matrix which translate to a center before rotation and translate afterward
|
||||
template <class T>
|
||||
inline void CMatrix4<T>::setRotationCenter(const core::vector3df ¢er, const core::vector3df &translation)
|
||||
@ -2136,7 +2102,6 @@ namespace core
|
||||
Uw Vw 0 0
|
||||
*/
|
||||
|
||||
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::buildTextureTransform(f32 rotateRad,
|
||||
const core::vector2df &rotatecenter,
|
||||
@ -2171,7 +2136,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// rotate about z axis, center ( 0.5, 0.5 )
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::setTextureRotationCenter(f32 rotateRad)
|
||||
@ -2193,7 +2157,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::setTextureTranslate(f32 x, f32 y)
|
||||
{
|
||||
@ -2257,7 +2220,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// sets all matrix data members at once
|
||||
template <class T>
|
||||
inline CMatrix4<T> &CMatrix4<T>::setM(const T *data)
|
||||
@ -2270,7 +2232,6 @@ namespace core
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
// sets if the matrix is definitely identity matrix
|
||||
template <class T>
|
||||
inline void CMatrix4<T>::setDefinitelyIdentityMatrix(bool isDefinitelyIdentityMatrix)
|
||||
@ -2282,7 +2243,6 @@ namespace core
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
// gets if the matrix is definitely identity matrix
|
||||
template <class T>
|
||||
inline bool CMatrix4<T>::getDefinitelyIdentityMatrix() const
|
||||
@ -2294,7 +2254,6 @@ namespace core
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
//! Compare two matrices using the equal method
|
||||
template <class T>
|
||||
inline bool CMatrix4<T>::equals(const core::CMatrix4<T> &other, const T tolerance) const
|
||||
@ -2310,7 +2269,6 @@ namespace core
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// Multiply by scalar.
|
||||
template <class T>
|
||||
inline CMatrix4<T> operator*(const T scalar, const CMatrix4<T> &mat)
|
||||
@ -2318,7 +2276,6 @@ namespace core
|
||||
return mat * scalar;
|
||||
}
|
||||
|
||||
|
||||
//! Typedef for f32 matrix
|
||||
typedef CMatrix4<f32> matrix4;
|
||||
|
||||
@ -2327,5 +2284,3 @@ namespace core
|
||||
|
||||
} // end namespace core
|
||||
} // end namespace irr
|
||||
|
||||
|
||||
|
@ -30,7 +30,8 @@ struct SNamedPath
|
||||
SNamedPath() {}
|
||||
|
||||
//! Constructor
|
||||
SNamedPath(const path& p) : Path(p), InternalName( PathToName(p) )
|
||||
SNamedPath(const path &p) :
|
||||
Path(p), InternalName(PathToName(p))
|
||||
{
|
||||
}
|
||||
|
||||
@ -83,4 +84,3 @@ private:
|
||||
|
||||
} // io
|
||||
} // irr
|
||||
|
||||
|
@ -32,19 +32,24 @@ template <class T>
|
||||
class plane3d
|
||||
{
|
||||
public:
|
||||
|
||||
// Constructors
|
||||
|
||||
plane3d(): Normal(0,1,0) { recalculateD(vector3d<T>(0,0,0)); }
|
||||
plane3d() :
|
||||
Normal(0, 1, 0) { recalculateD(vector3d<T>(0, 0, 0)); }
|
||||
|
||||
plane3d(const vector3d<T>& MPoint, const vector3d<T>& Normal) : Normal(Normal) { recalculateD(MPoint); }
|
||||
plane3d(const vector3d<T> &MPoint, const vector3d<T> &Normal) :
|
||||
Normal(Normal) { recalculateD(MPoint); }
|
||||
|
||||
plane3d(T px, T py, T pz, T nx, T ny, T nz) : Normal(nx, ny, nz) { recalculateD(vector3d<T>(px, py, pz)); }
|
||||
plane3d(T px, T py, T pz, T nx, T ny, T nz) :
|
||||
Normal(nx, ny, nz) { recalculateD(vector3d<T>(px, py, pz)); }
|
||||
|
||||
plane3d(const vector3d<T> &point1, const vector3d<T> &point2, const vector3d<T> &point3)
|
||||
{ setPlane(point1, point2, point3); }
|
||||
{
|
||||
setPlane(point1, point2, point3);
|
||||
}
|
||||
|
||||
plane3d(const vector3d<T> & normal, const T d) : Normal(normal), D(d) { }
|
||||
plane3d(const vector3d<T> &normal, const T d) :
|
||||
Normal(normal), D(d) {}
|
||||
|
||||
// operators
|
||||
|
||||
@ -75,7 +80,6 @@ class plane3d
|
||||
recalculateD(point1);
|
||||
}
|
||||
|
||||
|
||||
//! Get an intersection with a 3d line.
|
||||
/** \param lineVect Vector of the line to intersect with.
|
||||
\param linePoint Point of the line to intersect with.
|
||||
@ -230,7 +234,6 @@ class plane3d
|
||||
T D;
|
||||
};
|
||||
|
||||
|
||||
//! Typedef for a f32 3d plane.
|
||||
typedef plane3d<f32> plane3df;
|
||||
|
||||
@ -239,5 +242,3 @@ typedef plane3d<s32> plane3di;
|
||||
|
||||
} // end namespace core
|
||||
} // end namespace irr
|
||||
|
||||
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user