Skip to content

D
deprecated-irrlicht-mac
Commit 1c9b2014 authored by cutealien's avatar cutealien
Browse files
Options

Cleaning up Meshviewer example. That was too confusing to use and the code got... 

Cleaning up Meshviewer example. That was too confusing to use and the code got too long for one file.


git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@4951 dfc29bdd-3216-0410-991c-e03cc46cb475
parent 38d83734
Show whitespace changes
Inline Side-by-side
Showing with 909 additions and 751 deletions
examples/22.MaterialViewer/MaterialViewer.cbp
View file @ 1c9b2014
...@@ -46,6 +46,7 @@ ...@@ -46,6 +46,7 @@
<Add library="Irrlicht" /> <Add library="Irrlicht" />
</Linker> </Linker>
<Unit filename="main.cpp" /> <Unit filename="main.cpp" />
<Unit filename="main.h" />
<Extensions> <Extensions>
<code_completion /> <code_completion />
<debugger /> <debugger />
......
examples/22.MaterialViewer/main.cpp
View file @ 1c9b2014
...@@ -3,12 +3,12 @@ ...@@ -3,12 +3,12 @@
This example can be used to play around with material settings and watch the results. This example can be used to play around with material settings and watch the results.
Only the default non-shader materials are used in here. Only the default non-shader materials are used in here.
You have two nodes to make it easier to see which difference your settings will make. You have a node witha mesh, one dynamic light and global ambient light to play around with.
Additionally you have one lightscenenode and you can set the global ambient values.
*/ */
#include <irrlicht.h> #include <irrlicht.h>
#include "driverChoice.h" #include "driverChoice.h"
#include "main.h"
using namespace irr; using namespace irr;
...@@ -122,11 +122,8 @@ video::E_VERTEX_TYPE getVertexTypeForMaterialType(video::E_MATERIAL_TYPE materia ...@@ -122,11 +122,8 @@ video::E_VERTEX_TYPE getVertexTypeForMaterialType(video::E_MATERIAL_TYPE materia
/* /*
Custom GUI-control to edit colorvalues. Custom GUI-control to edit colorvalues.
*/ */
class CColorControl : public gui::IGUIElement // Constructor
{ CColorControl::CColorControl(gui::IGUIEnvironment* guiEnv, const core::position2d<s32> & pos, const wchar_t *text, IGUIElement* parent, s32 id)
public:
// Constructor
CColorControl(gui::IGUIEnvironment* guiEnv, const core::position2d<s32> & pos, const wchar_t *text, IGUIElement* parent, s32 id=-1 )
: gui::IGUIElement(gui::EGUIET_ELEMENT, guiEnv, parent,id, core::rect< s32 >(pos, pos+core::dimension2d<s32>(80, 75))) : gui::IGUIElement(gui::EGUIET_ELEMENT, guiEnv, parent,id, core::rect< s32 >(pos, pos+core::dimension2d<s32>(80, 75)))
, DirtyFlag(true) , DirtyFlag(true)
, ColorStatic(0) , ColorStatic(0)
...@@ -134,7 +131,7 @@ public: ...@@ -134,7 +131,7 @@ public:
, EditRed(0) , EditRed(0)
, EditGreen(0) , EditGreen(0)
, EditBlue(0) , EditBlue(0)
{ {
using namespace gui; using namespace gui;
ButtonSetId = makeUniqueId(); ButtonSetId = makeUniqueId();
...@@ -152,55 +149,35 @@ public: ...@@ -152,55 +149,35 @@ public:
ColorStatic = guiEnv->addStaticText (L"", core::rect<s32>(60,15,80,75), true, false, groupElement, -1, true); ColorStatic = guiEnv->addStaticText (L"", core::rect<s32>(60,15,80,75), true, false, groupElement, -1, true);
guiEnv->addButton (core::rect<s32>(60,35,80,50), groupElement, ButtonSetId, L"set"); guiEnv->addButton (core::rect<s32>(60,35,80,50), groupElement, ButtonSetId, L"set");
SetEditsFromColor(Color); setEditsFromColor(Color);
} }
// event receiver // event receiver
virtual bool OnEvent(const SEvent &event) bool CColorControl::OnEvent(const SEvent &event)
{ {
if ( event.EventType != EET_GUI_EVENT ) if ( event.EventType != EET_GUI_EVENT )
return false; return false;
if ( event.GUIEvent.Caller->getID() == ButtonSetId && event.GUIEvent.EventType == gui::EGET_BUTTON_CLICKED ) if ( event.GUIEvent.Caller->getID() == ButtonSetId && event.GUIEvent.EventType == gui::EGET_BUTTON_CLICKED )
{ {
Color = GetColorFromEdits(); Color = getColorFromEdits();
SetEditsFromColor(Color); setEditsFromColor(Color);
} }
return false; return false;
} }
// set the color values // set the color values
void setColor(const video::SColor& col) void CColorControl::setColor(const video::SColor& col)
{ {
DirtyFlag = true; DirtyFlag = true;
Color = col; Color = col;
SetEditsFromColor(Color); setEditsFromColor(Color);
} }
// get the color values
const 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 // Add a staticbox for a description + an editbox so users can enter numbers
gui::IGUIEditBox* addEditForNumbers(gui::IGUIEnvironment* guiEnv, const core::position2d<s32> & pos, const wchar_t *text, s32 id, gui::IGUIElement * parent) gui::IGUIEditBox* CColorControl::addEditForNumbers(gui::IGUIEnvironment* guiEnv, const core::position2d<s32> & pos, const wchar_t *text, s32 id, gui::IGUIElement * parent)
{ {
using namespace gui; using namespace gui;
core::rect< s32 > rect(pos, pos+core::dimension2d<s32>(10, 15)); core::rect< s32 > rect(pos, pos+core::dimension2d<s32>(10, 15));
...@@ -209,11 +186,11 @@ protected: ...@@ -209,11 +186,11 @@ protected:
rect.LowerRightCorner.X += 20; rect.LowerRightCorner.X += 20;
gui::IGUIEditBox* edit = guiEnv->addEditBox(L"0", rect, true, parent, id); gui::IGUIEditBox* edit = guiEnv->addEditBox(L"0", rect, true, parent, id);
return edit; return edit;
} }
// Get the color value from the editfields // Get the color value from the editfields
video::SColor GetColorFromEdits() video::SColor CColorControl::getColorFromEdits()
{ {
video::SColor col; video::SColor col;
if (EditAlpha) if (EditAlpha)
...@@ -249,11 +226,11 @@ protected: ...@@ -249,11 +226,11 @@ protected:
} }
return col; return col;
} }
// Fill the editfields with the value for the given color // Fill the editfields with the value for the given color
void SetEditsFromColor(video::SColor col) void CColorControl::setEditsFromColor(video::SColor col)
{ {
DirtyFlag = true; DirtyFlag = true;
if ( EditAlpha ) if ( EditAlpha )
EditAlpha->setText( core::stringw(col.getAlpha()).c_str() ); EditAlpha->setText( core::stringw(col.getAlpha()).c_str() );
...@@ -265,58 +242,47 @@ protected: ...@@ -265,58 +242,47 @@ protected:
EditBlue->setText( core::stringw(col.getBlue()).c_str() ); EditBlue->setText( core::stringw(col.getBlue()).c_str() );
if ( ColorStatic ) if ( ColorStatic )
ColorStatic->setBackgroundColor(col); ColorStatic->setBackgroundColor(col);
} }
private:
bool DirtyFlag;
video::SColor Color;
s32 ButtonSetId;
gui::IGUIStaticText * ColorStatic;
gui::IGUIEditBox * EditAlpha;
gui::IGUIEditBox * EditRed;
gui::IGUIEditBox * EditGreen;
gui::IGUIEditBox * EditBlue;
};
/* /*
Custom GUI-control for to edit all colors typically used in materials and lights Custom GUI-control for to edit all colors typically used in materials and lights
*/ */
class CAllColorsControl : public gui::IGUIElement // Constructor
{ CTypicalColorsControl::CTypicalColorsControl(gui::IGUIEnvironment* guiEnv, const core::position2d<s32> & pos, bool hasEmissive, IGUIElement* parent, s32 id)
public:
// Constructor
CAllColorsControl(gui::IGUIEnvironment* guiEnv, const core::position2d<s32> & pos, const wchar_t * description, bool hasEmissive, IGUIElement* parent, s32 id=-1)
: gui::IGUIElement(gui::EGUIET_ELEMENT, guiEnv, parent,id, core::rect<s32>(pos,pos+core::dimension2d<s32>(60,250))) : gui::IGUIElement(gui::EGUIET_ELEMENT, guiEnv, parent,id, core::rect<s32>(pos,pos+core::dimension2d<s32>(60,250)))
, ControlAmbientColor(0), ControlDiffuseColor(0), ControlSpecularColor(0), ControlEmissiveColor(0) , ControlAmbientColor(0), ControlDiffuseColor(0), ControlSpecularColor(0), ControlEmissiveColor(0)
{
ControlAmbientColor = new CColorControl( guiEnv, core::position2d<s32>(0, 0), L"Ambient", this);
ControlDiffuseColor = new CColorControl( guiEnv, core::position2d<s32>(0, 75), L"Diffuse", this );
ControlSpecularColor = new CColorControl( guiEnv, core::position2d<s32>(0, 150), L"Specular", this );
if ( hasEmissive )
{ {
core::rect<s32> rect(0, 0, 60, 15); ControlEmissiveColor = new CColorControl( guiEnv, core::position2d<s32>(0, 225), L"Emissive", this );
guiEnv->addStaticText (description, rect, false, false, this, -1, false);
createColorControls(guiEnv, core::position2d<s32>(0, 15), hasEmissive);
} }
}
// Destructor // Destructor
virtual ~CAllColorsControl() CTypicalColorsControl::~CTypicalColorsControl()
{ {
ControlAmbientColor->drop(); ControlAmbientColor->drop();
ControlDiffuseColor->drop(); ControlDiffuseColor->drop();
if ( ControlEmissiveColor ) if ( ControlEmissiveColor )
ControlEmissiveColor->drop(); ControlEmissiveColor->drop();
ControlSpecularColor->drop(); ControlSpecularColor->drop();
} }
// Set the color values to those within the material // Set the color values to those within the material
void setColorsToMaterialColors(const video::SMaterial & material) void CTypicalColorsControl::setColorsToMaterialColors(const video::SMaterial & material)
{ {
ControlAmbientColor->setColor(material.AmbientColor); ControlAmbientColor->setColor(material.AmbientColor);
ControlDiffuseColor->setColor(material.DiffuseColor); ControlDiffuseColor->setColor(material.DiffuseColor);
ControlEmissiveColor->setColor(material.EmissiveColor); ControlEmissiveColor->setColor(material.EmissiveColor);
ControlSpecularColor->setColor(material.SpecularColor); ControlSpecularColor->setColor(material.SpecularColor);
} }
// Update all changed colors in the material // Update all changed colors in the material
void updateMaterialColors(video::SMaterial & material) void CTypicalColorsControl::updateMaterialColors(video::SMaterial & material)
{ {
if ( ControlAmbientColor->isDirty() ) if ( ControlAmbientColor->isDirty() )
material.AmbientColor = ControlAmbientColor->getColor(); material.AmbientColor = ControlAmbientColor->getColor();
if ( ControlDiffuseColor->isDirty() ) if ( ControlDiffuseColor->isDirty() )
...@@ -325,73 +291,52 @@ public: ...@@ -325,73 +291,52 @@ public:
material.EmissiveColor = ControlEmissiveColor->getColor(); material.EmissiveColor = ControlEmissiveColor->getColor();
if ( ControlSpecularColor->isDirty() ) if ( ControlSpecularColor->isDirty() )
material.SpecularColor = ControlSpecularColor->getColor(); material.SpecularColor = ControlSpecularColor->getColor();
} }
// Set the color values to those from the light data // Set the color values to those from the light data
void setColorsToLightDataColors(const video::SLight & lightData) void CTypicalColorsControl::setColorsToLightDataColors(const video::SLight & lightData)
{ {
ControlAmbientColor->setColor(lightData.AmbientColor.toSColor()); ControlAmbientColor->setColor(lightData.AmbientColor.toSColor());
ControlAmbientColor->setColor(lightData.DiffuseColor.toSColor()); ControlAmbientColor->setColor(lightData.DiffuseColor.toSColor());
ControlAmbientColor->setColor(lightData.SpecularColor.toSColor()); ControlAmbientColor->setColor(lightData.SpecularColor.toSColor());
} }
// Update all changed colors in the light data // Update all changed colors in the light data
void updateLightColors(video::SLight & lightData) void CTypicalColorsControl::updateLightColors(video::SLight & lightData) const
{ {
if ( ControlAmbientColor->isDirty() ) if ( ControlAmbientColor->isDirty() )
lightData.AmbientColor = video::SColorf( ControlAmbientColor->getColor() ); lightData.AmbientColor = video::SColorf( ControlAmbientColor->getColor() );
if ( ControlDiffuseColor->isDirty() ) if ( ControlDiffuseColor->isDirty() )
lightData.DiffuseColor = video::SColorf( ControlDiffuseColor->getColor() ); lightData.DiffuseColor = video::SColorf( ControlDiffuseColor->getColor() );
if ( ControlSpecularColor->isDirty() ) if ( ControlSpecularColor->isDirty() )
lightData.SpecularColor = video::SColorf(ControlSpecularColor->getColor() ); lightData.SpecularColor = video::SColorf(ControlSpecularColor->getColor() );
} }
// To reset the dirty flags // To reset the dirty flags
void resetDirty() void CTypicalColorsControl::resetDirty()
{ {
ControlAmbientColor->resetDirty(); ControlAmbientColor->resetDirty();
ControlDiffuseColor->resetDirty(); ControlDiffuseColor->resetDirty();
ControlSpecularColor->resetDirty(); ControlSpecularColor->resetDirty();
if ( ControlEmissiveColor ) if ( ControlEmissiveColor )
ControlEmissiveColor->resetDirty(); ControlEmissiveColor->resetDirty();
} }
protected:
void createColorControls(gui::IGUIEnvironment* guiEnv, const core::position2d<s32> & pos, bool hasEmissive)
{
ControlAmbientColor = new CColorControl( guiEnv, pos, L"ambient", this);
ControlDiffuseColor = new CColorControl( guiEnv, pos + core::position2d<s32>(0, 75), L"diffuse", this );
ControlSpecularColor = new CColorControl( guiEnv, pos + core::position2d<s32>(0, 150), L"specular", this );
if ( hasEmissive )
{
ControlEmissiveColor = new CColorControl( guiEnv, pos + core::position2d<s32>(0, 225), L"emissive", this );
}
}
private:
CColorControl* ControlAmbientColor;
CColorControl* ControlDiffuseColor;
CColorControl* ControlSpecularColor;
CColorControl* ControlEmissiveColor;
};
/* /*
GUI-Control to offer a selection of available textures. GUI-Control to offer a selection of available textures.
*/ */
class CTextureControl : public gui::IGUIElement CTextureControl::CTextureControl(gui::IGUIEnvironment* guiEnv, video::IVideoDriver * driver, const core::position2d<s32> & pos, IGUIElement* parent, s32 id)
: gui::IGUIElement(gui::EGUIET_ELEMENT, guiEnv, parent,id, core::rect<s32>(pos,pos+core::dimension2d<s32>(150,15)))
, DirtyFlag(true), ComboTexture(0)
{ {
public:
CTextureControl(gui::IGUIEnvironment* guiEnv, video::IVideoDriver * driver, const core::position2d<s32> & pos, IGUIElement* parent, s32 id=-1)
: gui::IGUIElement(gui::EGUIET_ELEMENT, guiEnv, parent,id, core::rect<s32>(pos,pos+core::dimension2d<s32>(100,15)))
, DirtyFlag(true), ComboTexture(0)
{
core::rect<s32> rectCombo(0, 0, AbsoluteRect.getWidth(),AbsoluteRect.getHeight()); core::rect<s32> rectCombo(0, 0, AbsoluteRect.getWidth(),AbsoluteRect.getHeight());
ComboTexture = guiEnv->addComboBox (rectCombo, this); ComboTexture = guiEnv->addComboBox (rectCombo, this);
updateTextures(driver); updateTextures(driver);
} }
virtual bool OnEvent(const SEvent &event) bool CTextureControl::OnEvent(const SEvent &event)
{ {
if ( event.EventType != EET_GUI_EVENT ) if ( event.EventType != EET_GUI_EVENT )
return false; return false;
...@@ -401,42 +346,43 @@ public: ...@@ -401,42 +346,43 @@ public:
} }
return false; return false;
} }
// Workaround for a problem with comboboxes. // 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. // 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(IGUIElement* element) bool CTextureControl::bringToFront(IGUIElement* element)
{ {
bool result = gui::IGUIElement::bringToFront(element); bool result = gui::IGUIElement::bringToFront(element);
if ( Parent && element == ComboTexture ) if ( Parent && element == ComboTexture )
result &= Parent->bringToFront(this); result &= Parent->bringToFront(this);
return result; return result;
} }
// return selected texturename (if any, otherwise 0) // return selected texturename (if any, otherwise 0)
const wchar_t * getSelectedTextureName() const const wchar_t * CTextureControl::getSelectedTextureName() const
{ {
s32 selected = ComboTexture->getSelected(); s32 selected = ComboTexture->getSelected();
if ( selected < 0 ) if ( selected < 0 )
return 0; return 0;
return ComboTexture->getItem(selected); return ComboTexture->getItem(selected);
} }
// reset the dirty flag void CTextureControl::selectTextureByName(const irr::core::stringw& name)
void resetDirty() {
for (u32 i=0; i< ComboTexture->getItemCount(); ++i)
{ {
DirtyFlag = false; if ( name == ComboTexture->getItem(i))
}
// when the texture was changed the dirty flag is set
bool isDirty() const
{ {
return DirtyFlag; ComboTexture->setSelected(i);
}; DirtyFlag = true;
return;
}
}
}
// Put the names of all currently loaded textures in a combobox // Put the names of all currently loaded textures in a combobox
void updateTextures(video::IVideoDriver * driver) void CTextureControl::updateTextures(video::IVideoDriver * driver)
{ {
s32 oldSelected = ComboTexture->getSelected(); s32 oldSelected = ComboTexture->getSelected();
s32 selectNew = -1; s32 selectNew = -1;
core::stringw oldTextureName; core::stringw oldTextureName;
...@@ -463,74 +409,30 @@ public: ...@@ -463,74 +409,30 @@ public:
ComboTexture->setSelected(selectNew); ComboTexture->setSelected(selectNew);
DirtyFlag = true; DirtyFlag = true;
} }
private:
bool DirtyFlag;
gui::IGUIComboBox * ComboTexture;
};
/* /*
Control which allows setting some of the material values for a meshscenenode Control which allows setting some of the material values for a meshscenenode
*/ */
struct SMeshNodeControl void SMaterialControl::init(scene::IMeshSceneNode* node, IrrlichtDevice * device, const core::position2d<s32> & pos, const wchar_t * description)
{ {
// constructor
SMeshNodeControl()
: Initialized(false), Driver(0), MeshManipulator(0), SceneNode(0), SceneNode2T(0), SceneNodeTangents(0)
, AllColorsControl(0), ButtonLighting(0), InfoLighting(0), ComboMaterial(0), TextureControl1(0), TextureControl2(0), ControlVertexColors(0)
{
}
// Destructor
virtual ~SMeshNodeControl()
{
if ( TextureControl1 )
TextureControl1->drop();
if ( TextureControl2 )
TextureControl2->drop();
if ( ControlVertexColors )
ControlVertexColors->drop();
if ( AllColorsControl )
AllColorsControl->drop();
}
void init(scene::IMeshSceneNode* node, IrrlichtDevice * device, const core::position2d<s32> & pos, const wchar_t * description)
{
if ( Initialized || !node || !device) // initializing twice or with invalid data not allowed if ( Initialized || !node || !device) // initializing twice or with invalid data not allowed
return; return;
Driver = device->getVideoDriver (); Driver = device->getVideoDriver ();
gui::IGUIEnvironment* guiEnv = device->getGUIEnvironment(); gui::IGUIEnvironment* guiEnv = device->getGUIEnvironment();
scene::ISceneManager* smgr = device->getSceneManager(); scene::ISceneManager* smgr = device->getSceneManager();
MeshManipulator = smgr->getMeshManipulator(); const video::SMaterial & material = node->getMaterial(0);
SceneNode = node; s32 top = pos.Y;
scene::IMeshManipulator * meshManip = smgr->getMeshManipulator();
scene::IMesh * mesh2T = meshManip->createMeshWith2TCoords(node->getMesh());
SceneNode2T = smgr->addMeshSceneNode(mesh2T, 0, -1, SceneNode->getPosition(), SceneNode->getRotation(), SceneNode->getScale() );
mesh2T->drop();
scene::IMesh * meshTangents = meshManip->createMeshWithTangents(node->getMesh(), false, false, false); // Description
SceneNodeTangents = smgr->addMeshSceneNode(meshTangents, 0, -1 guiEnv->addStaticText(description, core::rect<s32>(pos.X, top, pos.X+60, top+15), false, false, 0, -1, false);
, SceneNode->getPosition(), SceneNode->getRotation(), SceneNode->getScale() ); top += 15;
meshTangents->drop();
video::SMaterial & material = SceneNode->getMaterial(0); // Control for material type
material.Lighting = true; core::rect<s32> rectCombo(pos.X, top, 150, top+15);
AllColorsControl = new CAllColorsControl(guiEnv, pos, description, true, guiEnv->getRootGUIElement()); top += 15;
AllColorsControl->setColorsToMaterialColors(material);
core::rect<s32> rectBtn(pos + core::position2d<s32>(0, 320), core::dimension2d<s32>(60, 15));
ButtonLighting = guiEnv->addButton (rectBtn, 0, -1, L"Lighting");
ButtonLighting->setIsPushButton(true);
ButtonLighting->setPressed(material.Lighting);
core::rect<s32> rectInfo( rectBtn.LowerRightCorner.X, rectBtn.UpperLeftCorner.Y, rectBtn.LowerRightCorner.X+40, rectBtn.UpperLeftCorner.Y+15 );
InfoLighting = guiEnv->addStaticText(L"", rectInfo, true, false );
InfoLighting->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER );
core::rect<s32> rectCombo(pos.X, rectBtn.LowerRightCorner.Y, pos.X+100, rectBtn.LowerRightCorner.Y+15);
ComboMaterial = guiEnv->addComboBox (rectCombo); ComboMaterial = guiEnv->addComboBox (rectCombo);
for ( int i=0; i <= (int)video::EMT_ONETEXTURE_BLEND; ++i ) for ( int i=0; i <= (int)video::EMT_ONETEXTURE_BLEND; ++i )
{ {
...@@ -538,207 +440,145 @@ struct SMeshNodeControl ...@@ -538,207 +440,145 @@ struct SMeshNodeControl
} }
ComboMaterial->setSelected( (s32)material.MaterialType ); ComboMaterial->setSelected( (s32)material.MaterialType );
core::position2d<s32> posTex(rectCombo.UpperLeftCorner.X,rectCombo.LowerRightCorner.Y); // Control to enable/disabling material lighting
TextureControl1 = new CTextureControl(guiEnv, Driver, posTex, guiEnv->getRootGUIElement()); core::rect<s32> rectBtn(core::position2d<s32>(pos.X, top), core::dimension2d<s32>(100, 15));
posTex.Y += 15; top += 15;
TextureControl2 = new CTextureControl(guiEnv, Driver, posTex, guiEnv->getRootGUIElement()); ButtonLighting = guiEnv->addButton (rectBtn, 0, -1, L"Lighting");
ButtonLighting->setIsPushButton(true);
ButtonLighting->setPressed(material.Lighting);
core::rect<s32> rectInfo( rectBtn.LowerRightCorner.X, rectBtn.UpperLeftCorner.Y, rectBtn.LowerRightCorner.X+40, rectBtn.UpperLeftCorner.Y+15 );
InfoLighting = guiEnv->addStaticText(L"", rectInfo, true, false );
InfoLighting->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_CENTER );
core::position2d<s32> posVertexColors( posTex.X, posTex.Y + 15); // Controls for colors
ControlVertexColors = new CColorControl( guiEnv, posVertexColors, L"Vertex colors", guiEnv->getRootGUIElement()); TypicalColorsControl = new CTypicalColorsControl(guiEnv, core::position2d<s32>(pos.X, top), true, guiEnv->getRootGUIElement());
top += 300;
TypicalColorsControl->setColorsToMaterialColors(material);
video::S3DVertex * vertices = (video::S3DVertex *)node->getMesh()->getMeshBuffer(0)->getVertices(); // Controls for selecting the material textures
if ( vertices ) guiEnv->addStaticText(L"Textures", core::rect<s32>(pos.X, top, pos.X+60, top+15), false, false, 0, -1, false);
top += 15;
for (irr::u32 i=0; i<irr::video::MATERIAL_MAX_TEXTURES; ++i)
{ {
ControlVertexColors->setColor(vertices[0].Color); TextureControls[i] = new CTextureControl(guiEnv, Driver, core::position2di(pos.X, top), guiEnv->getRootGUIElement());
top += 15;
} }
Initialized = true; Initialized = true;
} }
void update() void SMaterialControl::update(scene::IMeshSceneNode* sceneNode, scene::IMeshSceneNode* sceneNode2T, scene::IMeshSceneNode* sceneNodeTangents)
{ {
if ( !Initialized ) if ( !Initialized )
return; return;
video::SMaterial & material = SceneNode->getMaterial(0); video::SMaterial & material = sceneNode->getMaterial(0);
video::SMaterial & material2T = SceneNode2T->getMaterial(0); video::SMaterial & material2T = sceneNode2T->getMaterial(0);
video::SMaterial & materialTangents = SceneNodeTangents->getMaterial(0); video::SMaterial & materialTangents = sceneNodeTangents->getMaterial(0);
s32 selectedMaterial = ComboMaterial->getSelected(); s32 selectedMaterial = ComboMaterial->getSelected();
if ( selectedMaterial >= (s32)video::EMT_SOLID && selectedMaterial <= (s32)video::EMT_ONETEXTURE_BLEND) if ( selectedMaterial >= (s32)video::EMT_SOLID && selectedMaterial <= (s32)video::EMT_ONETEXTURE_BLEND)
{ {
// Show the node which has a mesh to work with the currently selected material
video::E_VERTEX_TYPE vertexType = getVertexTypeForMaterialType((video::E_MATERIAL_TYPE)selectedMaterial); video::E_VERTEX_TYPE vertexType = getVertexTypeForMaterialType((video::E_MATERIAL_TYPE)selectedMaterial);
switch ( vertexType ) switch ( vertexType )
{ {
case video::EVT_STANDARD: case video::EVT_STANDARD:
material.MaterialType = (video::E_MATERIAL_TYPE)selectedMaterial; material.MaterialType = (video::E_MATERIAL_TYPE)selectedMaterial;
SceneNode->setVisible(true); sceneNode->setVisible(true);
SceneNode2T->setVisible(false); sceneNode2T->setVisible(false);
SceneNodeTangents->setVisible(false); sceneNodeTangents->setVisible(false);
break; break;
case video::EVT_2TCOORDS: case video::EVT_2TCOORDS:
material2T.MaterialType = (video::E_MATERIAL_TYPE)selectedMaterial; material2T.MaterialType = (video::E_MATERIAL_TYPE)selectedMaterial;
SceneNode->setVisible(false); sceneNode->setVisible(false);
SceneNode2T->setVisible(true); sceneNode2T->setVisible(true);
SceneNodeTangents->setVisible(false); sceneNodeTangents->setVisible(false);
break; break;
case video::EVT_TANGENTS: case video::EVT_TANGENTS:
materialTangents.MaterialType = (video::E_MATERIAL_TYPE)selectedMaterial; materialTangents.MaterialType = (video::E_MATERIAL_TYPE)selectedMaterial;
SceneNode->setVisible(false); sceneNode->setVisible(false);
SceneNode2T->setVisible(false); sceneNode2T->setVisible(false);
SceneNodeTangents->setVisible(true); sceneNodeTangents->setVisible(true);
break; break;
} }
} }
// Always update materials of all nodes, otherwise the tool is confusing to use.
updateMaterial(material); updateMaterial(material);
updateMaterial(material2T); updateMaterial(material2T);
updateMaterial(materialTangents); updateMaterial(materialTangents);
if ( ButtonLighting->isPressed() ) if ( ButtonLighting->isPressed() )
InfoLighting->setText(L"on"); InfoLighting->setText(L"is on");
else else
InfoLighting->setText(L"off"); InfoLighting->setText(L"is off");
AllColorsControl->resetDirty(); TypicalColorsControl->resetDirty();
TextureControl1->resetDirty();
TextureControl2->resetDirty();
ControlVertexColors->resetDirty();
}
void updateTextures() for (irr::u32 i=0; i<irr::video::MATERIAL_MAX_TEXTURES; ++i)
{ TextureControls[i]->resetDirty();
TextureControl1->updateTextures(Driver); }
TextureControl2->updateTextures(Driver);
}
protected: void SMaterialControl::updateTextures()
{
for (irr::u32 i=0; i<irr::video::MATERIAL_MAX_TEXTURES; ++i)
TextureControls[i]->updateTextures(Driver);
}
void updateMaterial(video::SMaterial & material) void SMaterialControl::selectTextures(const irr::core::stringw& name)
{ {
AllColorsControl->updateMaterialColors(material); for (irr::u32 i=0; i<irr::video::MATERIAL_MAX_TEXTURES; ++i)
TextureControls[i]->selectTextureByName(name);
}
void SMaterialControl::updateMaterial(video::SMaterial & material)
{
TypicalColorsControl->updateMaterialColors(material);
material.Lighting = ButtonLighting->isPressed(); material.Lighting = ButtonLighting->isPressed();
if ( TextureControl1->isDirty() ) for (irr::u32 i=0; i<irr::video::MATERIAL_MAX_TEXTURES; ++i)
{ {
material.TextureLayer[0].Texture = Driver->getTexture( io::path(TextureControl1->getSelectedTextureName()) ); if ( TextureControls[i]->isDirty() )
}
if ( TextureControl2->isDirty() )
{ {
material.TextureLayer[1].Texture = Driver->getTexture( io::path(TextureControl2->getSelectedTextureName()) ); material.TextureLayer[i].Texture = Driver->getTexture( io::path(TextureControls[i]->getSelectedTextureName()) );
}
if ( ControlVertexColors->isDirty() )
{
MeshManipulator->setVertexColors (SceneNode->getMesh(), ControlVertexColors->getColor());
MeshManipulator->setVertexColors (SceneNode2T->getMesh(), ControlVertexColors->getColor());
MeshManipulator->setVertexColors (SceneNodeTangents->getMesh(), ControlVertexColors->getColor());
} }
} }
}
bool Initialized;
video::IVideoDriver * Driver;
scene::IMeshManipulator* MeshManipulator;
scene::IMeshSceneNode* SceneNode;
scene::IMeshSceneNode* SceneNode2T;
scene::IMeshSceneNode* SceneNodeTangents;
CAllColorsControl* AllColorsControl;
gui::IGUIButton * ButtonLighting;
gui::IGUIStaticText* InfoLighting;
gui::IGUIComboBox * ComboMaterial;
CTextureControl* TextureControl1;
CTextureControl* TextureControl2;
CColorControl* ControlVertexColors;
};
/* /*
Control to allow setting the color values of a lightscenenode. Control to allow setting the color values of a lightscenenode.
*/ */
struct SLightNodeControl
{
// constructor
SLightNodeControl() : Initialized(false), SceneNode(0), AllColorsControl(0)
{
}
virtual ~SLightNodeControl()
{
if ( AllColorsControl )
AllColorsControl->drop();
}
void init(scene::ILightSceneNode* node, gui::IGUIEnvironment* guiEnv, const core::position2d<s32> & pos, const wchar_t * description) void SLightNodeControl::init(scene::ILightSceneNode* node, gui::IGUIEnvironment* guiEnv, const core::position2d<s32> & pos, const wchar_t * description)
{ {
if ( Initialized || !node || !guiEnv) // initializing twice or with invalid data not allowed if ( Initialized || !node || !guiEnv) // initializing twice or with invalid data not allowed
return; return;
SceneNode = node;
AllColorsControl = new CAllColorsControl(guiEnv, pos, description, false, guiEnv->getRootGUIElement()); guiEnv->addStaticText(description, core::rect<s32>(pos.X, pos.Y, pos.X+70, pos.Y+15), false, false, 0, -1, false);
const video::SLight & lightData = SceneNode->getLightData(); TypicalColorsControl = new CTypicalColorsControl(guiEnv, core::position2d<s32>(pos.X, pos.Y+15), false, guiEnv->getRootGUIElement());
AllColorsControl->setColorsToLightDataColors(lightData); const video::SLight & lightData = node->getLightData();
TypicalColorsControl->setColorsToLightDataColors(lightData);
Initialized = true; Initialized = true;
} }
void update() void SLightNodeControl::update(scene::ILightSceneNode* node)
{ {
if ( !Initialized ) if ( !Initialized )
return; return;
video::SLight & lightData = SceneNode->getLightData(); video::SLight & lightData = node->getLightData();
AllColorsControl->updateLightColors(lightData); TypicalColorsControl->updateLightColors(lightData);
} }
protected:
bool Initialized;
scene::ILightSceneNode* SceneNode;
CAllColorsControl* AllColorsControl;
};
/* /*
Application configuration Main application class
*/ */
struct SConfig
{
SConfig()
: RenderInBackground(true)
, DriverType(video::EDT_BURNINGSVIDEO)
, ScreenSize(640, 480)
{
}
bool RenderInBackground;
video::E_DRIVER_TYPE DriverType;
core::dimension2d<u32> ScreenSize;
};
/* /*
Main application class Event handler
*/ */
class CApp : public IEventReceiver bool CApp::OnEvent(const SEvent &event)
{ {
friend int main(int argc, char *argv[]);
public:
// constructor
CApp()
: IsRunning(false)
, Device(0)
, Camera(0)
, GlobalAmbient(0)
{
}
// destructor
~CApp()
{
}
// stop running - will quit at end of mainloop
void stopApp()
{
IsRunning = false;
}
// Event handler
virtual bool OnEvent(const SEvent &event)
{
if (event.EventType == EET_GUI_EVENT) if (event.EventType == EET_GUI_EVENT)
{ {
gui::IGUIEnvironment* env = Device->getGUIEnvironment(); gui::IGUIEnvironment* env = Device->getGUIEnvironment();
...@@ -756,7 +596,7 @@ public: ...@@ -756,7 +596,7 @@ public:
env->addFileOpenDialog(L"Please select a texture file to open"); env->addFileOpenDialog(L"Please select a texture file to open");
break; break;
case GUI_ID_QUIT: // File -> Quit case GUI_ID_QUIT: // File -> Quit
stopApp(); setRunning(false);
break; break;
} }
} }
...@@ -777,14 +617,12 @@ public: ...@@ -777,14 +617,12 @@ public:
} }
return false; return false;
} }
protected:
// Application initialization // Application initialization
// returns true when it was successful initialized, otherwise false. // returns true when it was successful initialized, otherwise false.
bool init(int argc, char *argv[]) bool CApp::init(int argc, char *argv[])
{ {
// ask user for driver // ask user for driver
Config.DriverType=driverChoiceConsole(); Config.DriverType=driverChoiceConsole();
if (Config.DriverType==video::EDT_COUNT) if (Config.DriverType==video::EDT_COUNT)
...@@ -800,6 +638,7 @@ protected: ...@@ -800,6 +638,7 @@ protected:
scene::ISceneManager* smgr = Device->getSceneManager(); scene::ISceneManager* smgr = Device->getSceneManager();
video::IVideoDriver * driver = Device->getVideoDriver (); video::IVideoDriver * driver = Device->getVideoDriver ();
gui::IGUIEnvironment* guiEnv = Device->getGUIEnvironment(); gui::IGUIEnvironment* guiEnv = Device->getGUIEnvironment();
MeshManipulator = smgr->getMeshManipulator();
// set a nicer font // set a nicer font
gui::IGUISkin* skin = guiEnv->getSkin(); gui::IGUISkin* skin = guiEnv->getSkin();
...@@ -826,29 +665,37 @@ protected: ...@@ -826,29 +665,37 @@ protected:
subMenuFile->addSeparator(); subMenuFile->addSeparator();
subMenuFile->addItem(L"Quit", GUI_ID_QUIT); subMenuFile->addItem(L"Quit", GUI_ID_QUIT);
const s32 controlsTop = 20;
// a static camera // a static camera
Camera = smgr->addCameraSceneNode (0, core::vector3df(0, 0, 0), Camera = smgr->addCameraSceneNode (0, core::vector3df(0, 40, -40),
core::vector3df(0, 0, 100), core::vector3df(0, 10, 0),
-1); -1);
// add the nodes which are used to show the materials // add the nodes which are used to show the materials
scene::IMeshSceneNode* nodeL = smgr->addCubeSceneNode (30.0f, 0, -1, SceneNode = smgr->addCubeSceneNode (30.0f, 0, -1,
core::vector3df(-35, 0, 100),
core::vector3df(0, 0, 0), core::vector3df(0, 0, 0),
core::vector3df(0.f, 45.f, 0.f),
core::vector3df(1.0f, 1.0f, 1.0f)); core::vector3df(1.0f, 1.0f, 1.0f));
NodeLeft.init( nodeL, Device, core::position2d<s32>(10,20), L"left node" ); MeshMaterialControl.init( SceneNode, Device, core::position2d<s32>(10,controlsTop), L"Material" );
MeshMaterialControl.selectTextures(core::stringw("CARO_A8R8G8B8")); // set a useful default texture
// create nodes with other vertex types
scene::IMesh * mesh2T = MeshManipulator->createMeshWith2TCoords(SceneNode->getMesh());
SceneNode2T = smgr->addMeshSceneNode(mesh2T, 0, -1, SceneNode->getPosition(), SceneNode->getRotation(), SceneNode->getScale() );
mesh2T->drop();
scene::IMesh * meshTangents = MeshManipulator->createMeshWithTangents(SceneNode->getMesh(), false, false, false);
SceneNodeTangents = smgr->addMeshSceneNode(meshTangents, 0, -1
, SceneNode->getPosition(), SceneNode->getRotation(), SceneNode->getScale() );
meshTangents->drop();
scene::IMeshSceneNode* nodeR = smgr->addCubeSceneNode (30.0f, 0, -1,
core::vector3df(35, 0, 100),
core::vector3df(0, 0, 0),
core::vector3df(1.0f, 1.0f, 1.0f));
NodeRight.init( nodeR, Device, core::position2d<s32>(530,20), L"right node" );
// add one light // add one light
scene::ILightSceneNode* nodeLight = smgr->addLightSceneNode(0, core::vector3df(0, 0, 0), NodeLight = smgr->addLightSceneNode(0, Camera->getPosition(),
video::SColorf(1.0f, 1.0f, 1.0f), video::SColorf(1.0f, 1.0f, 1.0f),
100.0f); 35.0f);
LightControl.init(nodeLight, guiEnv, core::position2d<s32>(270,20), L"light" ); LightControl.init(NodeLight, guiEnv, core::position2d<s32>(550,controlsTop), L"Dynamic light" );
// one large cube around everything. That's mainly to make the light more obvious. // one large cube around everything. That's mainly to make the light more obvious.
scene::IMeshSceneNode* backgroundCube = smgr->addCubeSceneNode (200.0f, 0, -1, core::vector3df(0, 0, 0), scene::IMeshSceneNode* backgroundCube = smgr->addCubeSceneNode (200.0f, 0, -1, core::vector3df(0, 0, 0),
...@@ -857,16 +704,28 @@ protected: ...@@ -857,16 +704,28 @@ protected:
backgroundCube->getMaterial(0).BackfaceCulling = false; // we are within the cube, so we have to disable backface culling to see it backgroundCube->getMaterial(0).BackfaceCulling = false; // we are within the cube, so we have to disable backface culling to see it
backgroundCube->getMaterial(0).EmissiveColor.set(255,50,50,50); // we keep some self lighting to keep texts visible backgroundCube->getMaterial(0).EmissiveColor.set(255,50,50,50); // we keep some self lighting to keep texts visible
// set the ambient light value
GlobalAmbient = new CColorControl( guiEnv, core::position2d<s32>(270, 300), L"global ambient", guiEnv->getRootGUIElement()); // Add a the mesh vertex color control
guiEnv->addStaticText(L"Mesh", core::rect<s32>(200, controlsTop, 270, controlsTop+15), false, false, 0, -1, false);
ControlVertexColors = new CColorControl( guiEnv, core::position2d<s32>(200, controlsTop+15), L"Vertex colors", guiEnv->getRootGUIElement());
video::S3DVertex * vertices = (video::S3DVertex *)SceneNode->getMesh()->getMeshBuffer(0)->getVertices();
if ( vertices )
{
ControlVertexColors->setColor(vertices[0].Color);
}
// Add a control for ambient light
GlobalAmbient = new CColorControl( guiEnv, core::position2d<s32>(550, 300), L"Global ambient", guiEnv->getRootGUIElement());
GlobalAmbient->setColor( smgr->getAmbientLight().toSColor() ); GlobalAmbient->setColor( smgr->getAmbientLight().toSColor() );
return true; return true;
} }
// Update one frame /*
bool update() Update one frame
{ */
bool CApp::update()
{
using namespace irr; using namespace irr;
video::IVideoDriver* videoDriver = Device->getVideoDriver(); video::IVideoDriver* videoDriver = Device->getVideoDriver();
...@@ -880,9 +739,17 @@ protected: ...@@ -880,9 +739,17 @@ protected:
gui::IGUISkin * skin = guiEnv->getSkin(); gui::IGUISkin * skin = guiEnv->getSkin();
// update our controls // update our controls
NodeLeft.update(); MeshMaterialControl.update(SceneNode, SceneNode2T, SceneNodeTangents);
NodeRight.update(); LightControl.update(NodeLight);
LightControl.update();
// Update vertices
if ( ControlVertexColors->isDirty() )
{
MeshManipulator->setVertexColors (SceneNode->getMesh(), ControlVertexColors->getColor());
MeshManipulator->setVertexColors (SceneNode2T->getMesh(), ControlVertexColors->getColor());
MeshManipulator->setVertexColors (SceneNodeTangents->getMesh(), ControlVertexColors->getColor());
ControlVertexColors->resetDirty();
}
// update ambient light settings // update ambient light settings
if ( GlobalAmbient->isDirty() ) if ( GlobalAmbient->isDirty() )
...@@ -901,45 +768,37 @@ protected: ...@@ -901,45 +768,37 @@ protected:
videoDriver->endScene(); videoDriver->endScene();
} }
return true; // be nice
} Device->sleep( 5 );
// Run the application. Our main loop.
void run()
{
IsRunning = true;
if ( !Device ) return true;
return; }
// main application loop // Close down the application
while(IsRunning) void CApp::quit()
{
IsRunning = false;
if ( ControlVertexColors )
{ {
if ( !update() ) ControlVertexColors->drop();
break; ControlVertexColors = NULL;
Device->sleep( 5 );
}
} }
if ( GlobalAmbient )
// Close down the application
void quit()
{ {
IsRunning = false;
GlobalAmbient->drop(); GlobalAmbient->drop();
GlobalAmbient = NULL; GlobalAmbient = NULL;
}
if ( Device ) if ( Device )
{ {
Device->closeDevice(); Device->closeDevice();
Device->drop(); Device->drop();
Device = NULL; Device = NULL;
} }
} }
// Create some useful textures. // Create some useful textures.
// Note that the function put readability over speed, you shouldn't use setPixel at runtime but for initialization it's nice. void CApp::createDefaultTextures(video::IVideoDriver * driver)
void createDefaultTextures(video::IVideoDriver * driver) {
{
const u32 width = 256; const u32 width = 256;
const u32 height = 256; const u32 height = 256;
video::IImage * imageA8R8G8B8 = driver->createImage (video::ECF_A8R8G8B8, core::dimension2d<u32>(width, height)); video::IImage * imageA8R8G8B8 = driver->createImage (video::ECF_A8R8G8B8, core::dimension2d<u32>(width, height));
...@@ -947,7 +806,8 @@ protected: ...@@ -947,7 +806,8 @@ protected:
return; return;
const u32 pitch = imageA8R8G8B8->getPitch(); const u32 pitch = imageA8R8G8B8->getPitch();
// some nice square-pattern with 9 typical colors // Some nice square-pattern with 9 typical colors
// Note that the function put readability over speed, you shouldn't use setPixel at runtime but for initialization it's nice.
for ( u32 y = 0; y < height; ++ y ) for ( u32 y = 0; y < height; ++ y )
{ {
for ( u32 x = 0; x < pitch; ++x ) for ( u32 x = 0; x < pitch; ++x )
...@@ -1002,29 +862,17 @@ protected: ...@@ -1002,29 +862,17 @@ protected:
driver->addTexture (io::path("GRAYSCALE_A8R8G8B8"), imageA8R8G8B8); driver->addTexture (io::path("GRAYSCALE_A8R8G8B8"), imageA8R8G8B8);
imageA8R8G8B8->drop(); imageA8R8G8B8->drop();
} }
// Load a texture and make sure nodes know it when more textures are available. // Load a texture and make sure nodes know it when more textures are available.
void loadTexture(const io::path &name) void CApp::loadTexture(const io::path &name)
{ {
Device->getVideoDriver()->getTexture(name); Device->getVideoDriver()->getTexture(name);
NodeLeft.updateTextures(); MeshMaterialControl.updateTextures();
NodeRight.updateTextures(); }
}
private:
SConfig Config;
volatile bool IsRunning;
IrrlichtDevice * Device;
scene::ICameraSceneNode * Camera;
SMeshNodeControl NodeLeft;
SMeshNodeControl NodeRight;
SLightNodeControl LightControl;
CColorControl * GlobalAmbient;
};
/* /*
A very short main as we do everything else in classes. Short main as most is done in classes.
*/ */
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
...@@ -1033,10 +881,21 @@ int main(int argc, char *argv[]) ...@@ -1033,10 +881,21 @@ int main(int argc, char *argv[])
if ( !APP.init(argc, argv) ) if ( !APP.init(argc, argv) )
{ {
printf("init failed\n"); printf("init failed\n");
APP.quit();
return 1; return 1;
} }
APP.run(); APP.setRunning(true);
/*
main application loop
*/
while(APP.isRunning())
{
if ( !APP.update() )
break;
}
APP.quit(); APP.quit();
return 0; return 0;
......
examples/22.MaterialViewer/main.h 0 → 100644
View file @ 1c9b2014
#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();
// 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);
// 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);
// 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
*/
struct SMaterialControl
{
// constructor
SMaterialControl()
: Initialized(false), Driver(0)
, TypicalColorsControl(0), ButtonLighting(0), InfoLighting(0), ComboMaterial(0)
{
for (irr::u32 i=0; i<irr::video::MATERIAL_MAX_TEXTURES; ++i)
TextureControls[i] = 0;
}
// Destructor
~SMaterialControl()
{
for (irr::u32 i=0; i<irr::video::MATERIAL_MAX_TEXTURES; ++i)
{
if (TextureControls[i] )
TextureControls[i]->drop();
}
if ( TypicalColorsControl )
TypicalColorsControl->drop();
}
void init(irr::scene::IMeshSceneNode* node, irr::IrrlichtDevice * device, const irr::core::position2d<irr::s32> & pos, const wchar_t * description);
void update(irr::scene::IMeshSceneNode* sceneNode, irr::scene::IMeshSceneNode* sceneNode2T, irr::scene::IMeshSceneNode* sceneNodeTangents);
void updateTextures();
void selectTextures(const irr::core::stringw& name);
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;
CTextureControl* TextureControls[irr::video::MATERIAL_MAX_TEXTURES];
};
/*
Control to allow setting the color values of a lightscenenode.
*/
struct SLightNodeControl
{
// constructor
SLightNodeControl() : Initialized(false), TypicalColorsControl(0)
{}
~SLightNodeControl()
{
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)
, Device(0)
, MeshManipulator(0)
, Camera(0)
, SceneNode(0), SceneNode2T(0), SceneNodeTangents(0), NodeLight(0)
, ControlVertexColors(0)
, GlobalAmbient(0)
{
}
// 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();
// Run the application. Our main loop.
void run();
// 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);
private:
SConfig Config;
bool IsRunning;
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;
SMaterialControl MeshMaterialControl;
SLightNodeControl LightControl;
CColorControl* ControlVertexColors;
CColorControl* GlobalAmbient;
};
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment