335 lines
8.7 KiB
C++
335 lines
8.7 KiB
C++
#ifndef EXAMPLE22_MATERIAL_VIEWER_MAIN_H
|
|
#define EXAMPLE22_MATERIAL_VIEWER_MAIN_H
|
|
|
|
#include <irrlicht.h>
|
|
|
|
// Helper control to allow setting colors
|
|
class CColorControl : public irr::gui::IGUIElement
|
|
{
|
|
public:
|
|
CColorControl(irr::gui::IGUIEnvironment* guiEnv, const irr::core::position2d<irr::s32> & pos, const wchar_t *text, irr::gui::IGUIElement* parent, irr::s32 id=-1);
|
|
|
|
// Event receiver
|
|
virtual bool OnEvent(const irr::SEvent &event);
|
|
|
|
// Set the color values
|
|
void setColor(const irr::video::SColor& col);
|
|
|
|
// Get the color values
|
|
const irr::video::SColor& getColor() const
|
|
{
|
|
return Color;
|
|
}
|
|
|
|
// To reset the dirty flag
|
|
void resetDirty()
|
|
{
|
|
DirtyFlag = false;
|
|
}
|
|
|
|
// when the color was changed the dirty flag is set
|
|
bool isDirty() const
|
|
{
|
|
return DirtyFlag;
|
|
};
|
|
|
|
protected:
|
|
|
|
// Add a staticbox for a description + an editbox so users can enter numbers
|
|
irr::gui::IGUIEditBox* addEditForNumbers(irr::gui::IGUIEnvironment* guiEnv, const irr::core::position2d<irr::s32> & pos, const wchar_t *text, irr::s32 id, irr::gui::IGUIElement * parent);
|
|
|
|
// Get the color value from the editfields
|
|
irr::video::SColor getColorFromEdits() const;
|
|
|
|
// Fill the editfields with the value for the given color
|
|
void setEditsFromColor(irr::video::SColor col);
|
|
|
|
private:
|
|
|
|
bool DirtyFlag;
|
|
irr::video::SColor Color;
|
|
irr::s32 ButtonSetId;
|
|
irr::gui::IGUIStaticText * ColorStatic;
|
|
irr::gui::IGUIEditBox * EditAlpha;
|
|
irr::gui::IGUIEditBox * EditRed;
|
|
irr::gui::IGUIEditBox * EditGreen;
|
|
irr::gui::IGUIEditBox * EditBlue;
|
|
};
|
|
|
|
/*
|
|
Custom GUI-control for to edit all colors typically used in materials and lights
|
|
*/
|
|
class CTypicalColorsControl : public irr::gui::IGUIElement
|
|
{
|
|
public:
|
|
// Constructor
|
|
CTypicalColorsControl(irr::gui::IGUIEnvironment* guiEnv, const irr::core::position2d<irr::s32> & pos, bool hasEmissive, irr::gui::IGUIElement* parent, irr::s32 id=-1);
|
|
|
|
// Destructor
|
|
virtual ~CTypicalColorsControl();
|
|
|
|
// Set the color values to those within the material
|
|
void setColorsToMaterialColors(const irr::video::SMaterial & material);
|
|
|
|
// Update all changed colors in the material
|
|
void updateMaterialColors(irr::video::SMaterial & material) const;
|
|
|
|
// Set the color values to those from the light data
|
|
void setColorsToLightDataColors(const irr::video::SLight & lightData);
|
|
|
|
// Update all changed colors in the light data
|
|
void updateLightColors(irr::video::SLight & lightData) const;
|
|
|
|
// To reset the dirty flags
|
|
void resetDirty();
|
|
|
|
private:
|
|
CColorControl* ControlAmbientColor;
|
|
CColorControl* ControlDiffuseColor;
|
|
CColorControl* ControlSpecularColor;
|
|
CColorControl* ControlEmissiveColor;
|
|
};
|
|
|
|
/*
|
|
GUI-Control to offer a selection of available textures.
|
|
*/
|
|
class CTextureControl : public irr::gui::IGUIElement
|
|
{
|
|
public:
|
|
CTextureControl(irr::gui::IGUIEnvironment* guiEnv, irr::video::IVideoDriver * driver, const irr::core::position2d<irr::s32> & pos, irr::gui::IGUIElement* parent, irr::s32 id=-1);
|
|
|
|
virtual bool OnEvent(const irr::SEvent &event);
|
|
|
|
// Workaround for a problem with comboboxes.
|
|
// We have to get in front when the combobox wants to get in front or combobox-list might be drawn below other elements.
|
|
virtual bool bringToFront(irr::gui::IGUIElement* element);
|
|
|
|
// Return selected texturename (if any, otherwise 0)
|
|
const wchar_t * getSelectedTextureName() const;
|
|
|
|
// Change active selectionbased on the texture name
|
|
void selectTextureByName(const irr::core::stringw& name);
|
|
|
|
// Set dirty flag (node will update texture)
|
|
void setDirty()
|
|
{
|
|
DirtyFlag = true;
|
|
}
|
|
|
|
// Reset the dirty flag
|
|
void resetDirty()
|
|
{
|
|
DirtyFlag = false;
|
|
}
|
|
|
|
// When the texture was changed the dirty flag is set
|
|
bool isDirty() const
|
|
{
|
|
return DirtyFlag;
|
|
};
|
|
|
|
// Put the names of all currently loaded textures in a combobox
|
|
void updateTextures(irr::video::IVideoDriver * driver);
|
|
|
|
private:
|
|
bool DirtyFlag;
|
|
irr::gui::IGUIComboBox * ComboTexture;
|
|
};
|
|
|
|
/*
|
|
Control which allows setting some of the material values for a meshscenenode
|
|
*/
|
|
class CMaterialControl
|
|
{
|
|
public:
|
|
// constructor
|
|
CMaterialControl()
|
|
: Initialized(false), Driver(0)
|
|
, TypicalColorsControl(0), ButtonLighting(0), InfoLighting(0), ComboMaterial(0)
|
|
{}
|
|
|
|
// Destructor
|
|
~CMaterialControl()
|
|
{
|
|
for (irr::u32 i=0; i<TextureControls.size(); ++i)
|
|
{
|
|
if (TextureControls[i] )
|
|
TextureControls[i]->drop();
|
|
}
|
|
if ( TypicalColorsControl )
|
|
TypicalColorsControl->drop();
|
|
}
|
|
|
|
void init(irr::IrrlichtDevice * device, const irr::core::position2d<irr::s32> & pos, const wchar_t * description);
|
|
|
|
void setMaterial(const irr::video::SMaterial & material);
|
|
|
|
void update(irr::scene::IMeshSceneNode* sceneNode, irr::scene::IMeshSceneNode* sceneNode2T, irr::scene::IMeshSceneNode* sceneNodeTangents);
|
|
|
|
void updateTextures();
|
|
|
|
void selectTextures(const irr::core::stringw& name);
|
|
|
|
bool isLightingEnabled() const;
|
|
|
|
protected:
|
|
|
|
void updateMaterial(irr::video::SMaterial & material);
|
|
|
|
bool Initialized;
|
|
irr::video::IVideoDriver * Driver;
|
|
CTypicalColorsControl* TypicalColorsControl;
|
|
irr::gui::IGUIButton * ButtonLighting;
|
|
irr::gui::IGUIStaticText* InfoLighting;
|
|
irr::gui::IGUIComboBox * ComboMaterial;
|
|
irr::core::array<CTextureControl*> TextureControls;
|
|
};
|
|
|
|
/*
|
|
Control to allow setting the color values of a lightscenenode.
|
|
*/
|
|
class CLightNodeControl
|
|
{
|
|
public:
|
|
// constructor
|
|
CLightNodeControl() : Initialized(false), TypicalColorsControl(0)
|
|
{}
|
|
|
|
~CLightNodeControl()
|
|
{
|
|
if ( TypicalColorsControl )
|
|
TypicalColorsControl->drop();
|
|
}
|
|
|
|
void init(irr::scene::ILightSceneNode* node, irr::gui::IGUIEnvironment* guiEnv, const irr::core::position2d<irr::s32> & pos, const wchar_t * description);
|
|
|
|
void update(irr::scene::ILightSceneNode* node);
|
|
|
|
protected:
|
|
bool Initialized;
|
|
CTypicalColorsControl* TypicalColorsControl;
|
|
};
|
|
|
|
/*
|
|
Application configuration
|
|
*/
|
|
struct SConfig
|
|
{
|
|
SConfig()
|
|
: RenderInBackground(true)
|
|
, DriverType(irr::video::EDT_NULL)
|
|
, ScreenSize(640, 480)
|
|
{
|
|
}
|
|
|
|
bool RenderInBackground;
|
|
irr::video::E_DRIVER_TYPE DriverType;
|
|
irr::core::dimension2d<irr::u32> ScreenSize;
|
|
};
|
|
|
|
/*
|
|
Main application class
|
|
*/
|
|
class CApp : public irr::IEventReceiver
|
|
{
|
|
friend int main(int argc, char *argv[]);
|
|
|
|
public:
|
|
// constructor
|
|
CApp()
|
|
: IsRunning(false)
|
|
, RealTimeTick(0)
|
|
, Device(0)
|
|
, MeshManipulator(0)
|
|
, Camera(0)
|
|
, SceneNode(0), SceneNode2T(0), SceneNodeTangents(0), NodeLight(0)
|
|
, CameraRotationAxis(irr::core::vector3df(1,0,0))
|
|
, LightRotationAxis(irr::core::vector3df(1,0,0))
|
|
, MeshMaterialControl(0)
|
|
, LightControl(0)
|
|
, ComboMeshType(0)
|
|
, ControlVertexColors(0)
|
|
, GlobalAmbient(0)
|
|
, MousePressed(false)
|
|
{
|
|
memset(KeysPressed, 0, sizeof KeysPressed);
|
|
}
|
|
|
|
// destructor
|
|
~CApp()
|
|
{
|
|
}
|
|
|
|
// Tell it to stop running
|
|
void setRunning(bool appRuns)
|
|
{
|
|
IsRunning = appRuns;
|
|
}
|
|
|
|
// Check if it should continue running
|
|
bool isRunning() const
|
|
{
|
|
return IsRunning;
|
|
}
|
|
|
|
// Event handler
|
|
virtual bool OnEvent(const irr::SEvent &event);
|
|
|
|
protected:
|
|
|
|
// Application initialization
|
|
// returns true when it was successful initialized, otherwise false.
|
|
bool init(int argc, char *argv[]);
|
|
|
|
// Update one frame
|
|
bool update();
|
|
|
|
// Close down the application
|
|
void quit();
|
|
|
|
// Create some useful textures.
|
|
void createDefaultTextures(irr::video::IVideoDriver * driver);
|
|
|
|
// Load a texture and make sure nodes know it when more textures are available.
|
|
void loadTexture(const irr::io::path &name);
|
|
|
|
// Rotate a node around the origin (0,0,0)
|
|
void RotateHorizontal(irr::scene::ISceneNode* node, irr::f32 angle);
|
|
void RotateAroundAxis(irr::scene::ISceneNode* node, irr::f32 angle, const irr::core::vector3df& axis);
|
|
void ZoomOut(irr::scene::ISceneNode* node, irr::f32 units);
|
|
void UpdateRotationAxis(irr::scene::ISceneNode* node, irr::core::vector3df& axis);
|
|
|
|
enum ENodeType
|
|
{
|
|
ENT_CUBE,
|
|
ENT_SPHERE
|
|
};
|
|
void setActiveMeshNodeType(ENodeType nodeType);
|
|
|
|
irr::scene::IMeshSceneNode* getVisibleMeshNode() const;
|
|
|
|
private:
|
|
SConfig Config;
|
|
bool IsRunning;
|
|
irr::u32 RealTimeTick;
|
|
irr::IrrlichtDevice * Device;
|
|
irr::scene::IMeshManipulator* MeshManipulator;
|
|
irr::scene::ICameraSceneNode * Camera;
|
|
irr::scene::IMeshSceneNode* SceneNode;
|
|
irr::scene::IMeshSceneNode* SceneNode2T;
|
|
irr::scene::IMeshSceneNode* SceneNodeTangents;
|
|
irr::scene::ILightSceneNode* NodeLight;
|
|
irr::core::vector3df CameraRotationAxis;
|
|
irr::core::vector3df LightRotationAxis;
|
|
CMaterialControl* MeshMaterialControl;
|
|
CLightNodeControl* LightControl;
|
|
irr::gui::IGUIComboBox* ComboMeshType;
|
|
CColorControl* ControlVertexColors;
|
|
CColorControl* GlobalAmbient;
|
|
bool KeysPressed[irr::KEY_KEY_CODES_COUNT];
|
|
bool MousePressed;
|
|
irr::core::position2d<irr::s32> MouseStart;
|
|
};
|
|
|
|
#endif
|