v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix win32-build for assimp_viewer . 

Signed-off-by: Kim Kulling <kim.kulling@googlemail.com>
pull/664/head
Kim Kulling 2015-04-17 20:02:55 +02:00
parent f435712273
commit 76dd9467b2
24 changed files with 4278 additions and 4158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -58,3 +58,4 @@ test/gtest/src/gtest-stamp/gtest-gitinfo.txt
test/gtest/src/gtest-stamp/gtest-gitclone-lastrun.txt test/gtest/src/gtest-stamp/gtest-gitclone-lastrun.txt
Assimp.opensdf Assimp.opensdf
contrib/zlib/CTestTestfile.cmake contrib/zlib/CTestTestfile.cmake
ipch/assimp_viewer-44bbbcd1/assimp_viewerd-ccc45335.ipch

2
code/StringComparison.h
View File

@ -51,6 +51,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define INCLUDED_AI_STRING_WORKERS_H #define INCLUDED_AI_STRING_WORKERS_H
#include "../include/assimp/ai_assert.h" #include "../include/assimp/ai_assert.h"
#include "StringComparison.h"
#include <string.h> #include <string.h>
#include <stdint.h> #include <stdint.h>
#include <string> #include <string>

1
tools/assimp_view/AnimEvaluator.cpp
View File

@ -39,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#include "stdafx.h"
#include "assimp_view.h" #include "assimp_view.h"
using namespace AssimpView; using namespace AssimpView;

327
tools/assimp_view/AssetHelper.h
View File

@ -43,195 +43,204 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#if (!defined AV_ASSET_HELPER_H_INCLUDED) #if (!defined AV_ASSET_HELPER_H_INCLUDED)
#define AV_ASSET_HELPER_H_INCLUDED #define AV_ASSET_HELPER_H_INCLUDED
class SceneAnimator; #include <d3d9.h>
#include <d3dx9.h>
#include <d3dx9mesh.h>
//------------------------------------------------------------------------------- #include <assimp/scene.h>
/** \brief Class to wrap ASSIMP's asset output structures
*/
//-------------------------------------------------------------------------------
class AssetHelper
{
public:
enum
{
// the original normal set will be used
ORIGINAL = 0x0u,
// a smoothed normal set will be used namespace AssimpView {
SMOOTH = 0x1u,
// a hard normal set will be used class SceneAnimator;
HARD = 0x2u,
};
// default constructor //-------------------------------------------------------------------------------
AssetHelper() /** \brief Class to wrap ASSIMP's asset output structures
: iNormalSet(ORIGINAL) */
{ //-------------------------------------------------------------------------------
mAnimator = NULL; class AssetHelper
apcMeshes = NULL; {
pcScene = NULL; public:
} enum
{
// the original normal set will be used
ORIGINAL = 0x0u,
//--------------------------------------------------------------- // a smoothed normal set will be used
// default vertex data structure SMOOTH = 0x1u,
// (even if tangents, bitangents or normals aren't
// required by the shader they will be committed to the GPU)
//---------------------------------------------------------------
struct Vertex
{
aiVector3D vPosition;
aiVector3D vNormal;
D3DCOLOR dColorDiffuse; // a hard normal set will be used
aiVector3D vTangent; HARD = 0x2u,
aiVector3D vBitangent; };
aiVector2D vTextureUV;
aiVector2D vTextureUV2;
unsigned char mBoneIndices[4];
unsigned char mBoneWeights[4]; // last Weight not used, calculated inside the vertex shader
/** Returns the vertex declaration elements to create a declaration from. */ // default constructor
static D3DVERTEXELEMENT9* GetDeclarationElements() AssetHelper()
{ : iNormalSet( ORIGINAL )
static D3DVERTEXELEMENT9 decl[] = {
{ mAnimator = NULL;
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, apcMeshes = NULL;
{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 }, pcScene = NULL;
{ 0, 24, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 }, }
{ 0, 28, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0 },
{ 0, 40, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0 },
{ 0, 52, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
{ 0, 60, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 },
{ 0, 68, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0 },
{ 0, 72, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0 },
D3DDECL_END()
};
return decl; //---------------------------------------------------------------
} // default vertex data structure
}; // (even if tangents, bitangents or normals aren't
// required by the shader they will be committed to the GPU)
//---------------------------------------------------------------
struct Vertex
{
aiVector3D vPosition;
aiVector3D vNormal;
//--------------------------------------------------------------- D3DCOLOR dColorDiffuse;
// FVF vertex structure used for normals aiVector3D vTangent;
//--------------------------------------------------------------- aiVector3D vBitangent;
struct LineVertex aiVector2D vTextureUV;
{ aiVector2D vTextureUV2;
aiVector3D vPosition; unsigned char mBoneIndices[ 4 ];
DWORD dColorDiffuse; unsigned char mBoneWeights[ 4 ]; // last Weight not used, calculated inside the vertex shader
// retrieves the FVF code of the vertex type /** Returns the vertex declaration elements to create a declaration from. */
static DWORD GetFVF() static D3DVERTEXELEMENT9* GetDeclarationElements()
{ {
return D3DFVF_DIFFUSE | D3DFVF_XYZ; static D3DVERTEXELEMENT9 decl[] =
} {
}; { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 },
{ 0, 24, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 },
{ 0, 28, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0 },
{ 0, 40, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0 },
{ 0, 52, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
{ 0, 60, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 },
{ 0, 68, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0 },
{ 0, 72, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0 },
D3DDECL_END()
};
//--------------------------------------------------------------- return decl;
// Helper class to store GPU related resources created for }
// a given aiMesh };
//---------------------------------------------------------------
class MeshHelper
{
public:
MeshHelper () //---------------------------------------------------------------
: // FVF vertex structure used for normals
piVB (NULL), //---------------------------------------------------------------
piIB (NULL), struct LineVertex
piVBNormals (NULL), {
piEffect (NULL), aiVector3D vPosition;
bSharedFX (false), DWORD dColorDiffuse;
piDiffuseTexture (NULL),
piSpecularTexture (NULL),
piAmbientTexture (NULL),
piEmissiveTexture (NULL),
piNormalTexture (NULL),
piOpacityTexture (NULL),
piShininessTexture (NULL),
piLightmapTexture (NULL),
twosided (false),
pvOriginalNormals (NULL)
{}
~MeshHelper () // retrieves the FVF code of the vertex type
{ static DWORD GetFVF()
// NOTE: This is done in DeleteAssetData() {
// TODO: Make this a proper d'tor return D3DFVF_DIFFUSE | D3DFVF_XYZ;
} }
};
// shading mode to use. Either Lambert or otherwise phong //---------------------------------------------------------------
// will be used in every case // Helper class to store GPU related resources created for
aiShadingMode eShadingMode; // a given aiMesh
//---------------------------------------------------------------
class MeshHelper
{
public:
// vertex buffer MeshHelper()
IDirect3DVertexBuffer9* piVB; :
piVB( NULL ),
piIB( NULL ),
piVBNormals( NULL ),
piEffect( NULL ),
bSharedFX( false ),
piDiffuseTexture( NULL ),
piSpecularTexture( NULL ),
piAmbientTexture( NULL ),
piEmissiveTexture( NULL ),
piNormalTexture( NULL ),
piOpacityTexture( NULL ),
piShininessTexture( NULL ),
piLightmapTexture( NULL ),
twosided( false ),
pvOriginalNormals( NULL )
{}
// index buffer. For partially transparent meshes ~MeshHelper()
// created with dynamic usage to be able to update {
// the buffer contents quickly // NOTE: This is done in DeleteAssetData()
IDirect3DIndexBuffer9* piIB; // TODO: Make this a proper d'tor
}
// vertex buffer to be used to draw vertex normals // shading mode to use. Either Lambert or otherwise phong
// (vertex normals are generated in every case) // will be used in every case
IDirect3DVertexBuffer9* piVBNormals; aiShadingMode eShadingMode;
// shader to be used // vertex buffer
ID3DXEffect* piEffect; IDirect3DVertexBuffer9* piVB;
bool bSharedFX;
// material textures // index buffer. For partially transparent meshes
IDirect3DTexture9* piDiffuseTexture; // created with dynamic usage to be able to update
IDirect3DTexture9* piSpecularTexture; // the buffer contents quickly
IDirect3DTexture9* piAmbientTexture; IDirect3DIndexBuffer9* piIB;
IDirect3DTexture9* piEmissiveTexture;
IDirect3DTexture9* piNormalTexture;
IDirect3DTexture9* piOpacityTexture;
IDirect3DTexture9* piShininessTexture;
IDirect3DTexture9* piLightmapTexture;
// material colors // vertex buffer to be used to draw vertex normals
D3DXVECTOR4 vDiffuseColor; // (vertex normals are generated in every case)
D3DXVECTOR4 vSpecularColor; IDirect3DVertexBuffer9* piVBNormals;
D3DXVECTOR4 vAmbientColor;
D3DXVECTOR4 vEmissiveColor;
// opacity for the material // shader to be used
float fOpacity; ID3DXEffect* piEffect;
bool bSharedFX;
// shininess for the material // material textures
float fShininess; IDirect3DTexture9* piDiffuseTexture;
IDirect3DTexture9* piSpecularTexture;
IDirect3DTexture9* piAmbientTexture;
IDirect3DTexture9* piEmissiveTexture;
IDirect3DTexture9* piNormalTexture;
IDirect3DTexture9* piOpacityTexture;
IDirect3DTexture9* piShininessTexture;
IDirect3DTexture9* piLightmapTexture;
// strength of the specular highlight // material colors
float fSpecularStrength; D3DXVECTOR4 vDiffuseColor;
D3DXVECTOR4 vSpecularColor;
D3DXVECTOR4 vAmbientColor;
D3DXVECTOR4 vEmissiveColor;
// two-sided? // opacity for the material
bool twosided; float fOpacity;
// Stores a pointer to the original normal set of the asset // shininess for the material
aiVector3D* pvOriginalNormals; float fShininess;
};
// One instance per aiMesh in the globally loaded asset // strength of the specular highlight
MeshHelper** apcMeshes; float fSpecularStrength;
// Scene wrapper instance // two-sided?
aiScene* pcScene; bool twosided;
// Animation player to animate the scene if necessary // Stores a pointer to the original normal set of the asset
SceneAnimator* mAnimator; aiVector3D* pvOriginalNormals;
};
// Specifies the normal set to be used // One instance per aiMesh in the globally loaded asset
unsigned int iNormalSet; MeshHelper** apcMeshes;
// ------------------------------------------------------------------ // Scene wrapper instance
// set the normal set to be used aiScene* pcScene;
void SetNormalSet(unsigned int iSet);
// ------------------------------------------------------------------ // Animation player to animate the scene if necessary
// flip all normal vectors SceneAnimator* mAnimator;
void FlipNormals();
void FlipNormalsInt(); // Specifies the normal set to be used
}; unsigned int iNormalSet;
// ------------------------------------------------------------------
// set the normal set to be used
void SetNormalSet( unsigned int iSet );
// ------------------------------------------------------------------
// flip all normal vectors
void FlipNormals();
void FlipNormalsInt();
};
}
#endif // !! IG #endif // !! IG

3
tools/assimp_view/Background.cpp
View File

@ -39,12 +39,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#include "stdafx.h"
#include "assimp_view.h" #include "assimp_view.h"
namespace AssimpView { namespace AssimpView {
extern std::string g_szSkyboxShader;
// From: U3D build 1256 (src\kernel\graphic\scenegraph\SkyBox.cpp) // From: U3D build 1256 (src\kernel\graphic\scenegraph\SkyBox.cpp)
// ------------------------------------------------------------------------------ // ------------------------------------------------------------------------------

130
tools/assimp_view/Background.h
View File

@ -38,91 +38,91 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#pragma once
#if (!defined AV_BACKGROUND_H_INCLUDED) namespace AssimpView
#define AV_BACKGROUND_H_INCLUDED {
class CBackgroundPainter
{
CBackgroundPainter()
:
clrColor( D3DCOLOR_ARGB( 0xFF, 100, 100, 100 ) ),
pcTexture( NULL ),
piSkyBoxEffect( NULL ),
eMode( SIMPLE_COLOR )
{}
class CBackgroundPainter public:
{
CBackgroundPainter()
:
clrColor(D3DCOLOR_ARGB(0xFF,100,100,100)),
pcTexture(NULL),
piSkyBoxEffect(NULL),
eMode(SIMPLE_COLOR)
{}
public: // Supported background draw modi
enum MODE { SIMPLE_COLOR, TEXTURE_2D, TEXTURE_CUBE };
// Supported background draw modi // Singleton accessors
enum MODE {SIMPLE_COLOR, TEXTURE_2D, TEXTURE_CUBE}; static CBackgroundPainter s_cInstance;
inline static CBackgroundPainter& Instance()
{
return s_cInstance;
}
// Singleton accessors // set the current background color
static CBackgroundPainter s_cInstance; // (this removes any textures loaded)
inline static CBackgroundPainter& Instance () void SetColor( D3DCOLOR p_clrNew );
{
return s_cInstance;
}
// set the current background color // Setup a cubemap/a 2d texture as background
// (this removes any textures loaded) void SetCubeMapBG( const char* p_szPath );
void SetColor (D3DCOLOR p_clrNew); void SetTextureBG( const char* p_szPath );
// Setup a cubemap/a 2d texture as background // Called by the render loop
void SetCubeMapBG (const char* p_szPath); void OnPreRender();
void SetTextureBG (const char* p_szPath); void OnPostRender();
// Called by the render loop // Release any native resources associated with the instance
void OnPreRender(); void ReleaseNativeResource();
void OnPostRender();
// Release any native resources associated with the instance // Recreate any native resources associated with the instance
void ReleaseNativeResource(); void RecreateNativeResource();
// Recreate any native resources associated with the instance // Rotate the skybox
void RecreateNativeResource(); void RotateSB( const aiMatrix4x4* pm );
// Rotate the skybox // Reset the state of the skybox
void RotateSB(const aiMatrix4x4* pm); void ResetSB();
// Reset the state of the skybox inline MODE GetMode() const
void ResetSB(); {
return this->eMode;
}
inline MODE GetMode() const inline IDirect3DBaseTexture9* GetTexture()
{ {
return this->eMode; return this->pcTexture;
} }
inline IDirect3DBaseTexture9* GetTexture() inline ID3DXBaseEffect* GetEffect()
{ {
return this->pcTexture; return this->piSkyBoxEffect;
} }
inline ID3DXBaseEffect* GetEffect() private:
{
return this->piSkyBoxEffect;
}
private: void RemoveSBDeps();
void RemoveSBDeps(); // current background color
D3DCOLOR clrColor;
// current background color // current background texture
D3DCOLOR clrColor; IDirect3DBaseTexture9* pcTexture;
ID3DXEffect* piSkyBoxEffect;
// current background texture // current background mode
IDirect3DBaseTexture9* pcTexture; MODE eMode;
ID3DXEffect* piSkyBoxEffect;
// current background mode // path to the texture
MODE eMode; std::string szPath;
// path to the texture // transformation matrix for the skybox
std::string szPath; aiMatrix4x4 mMatrix;
};
// transformation matrix for the skybox }
aiMatrix4x4 mMatrix;
};
#endif // !! AV_BACKGROUND_H_INCLUDED

11
tools/assimp_view/Display.cpp
View File

@ -38,13 +38,16 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#include "stdafx.h"
#include "assimp_view.h" #include "assimp_view.h"
#include "AnimEvaluator.h"
#include "SceneAnimator.h"
namespace AssimpView { namespace AssimpView {
using namespace Assimp;
extern std::string g_szCheckerBackgroundShader;
struct SVertex struct SVertex
{ {
float x,y,z,w,u,v; float x,y,z,w,u,v;
@ -2240,7 +2243,7 @@ int CDisplay::RenderTextureView()
const float ny = (float)sRect.bottom; const float ny = (float)sRect.bottom;
const float x = (float)sDesc.Width; const float x = (float)sDesc.Width;
const float y = (float)sDesc.Height; const float y = (float)sDesc.Height;
float f = std::min((nx-30) / x,(ny-30) / y) * (m_fTextureZoom/1000.0f); float f = min((nx-30) / x,(ny-30) / y) * (m_fTextureZoom/1000.0f);
float fHalfX = (nx - (f * x)) / 2.0f; float fHalfX = (nx - (f * x)) / 2.0f;
float fHalfY = (ny - (f * y)) / 2.0f; float fHalfY = (ny - (f * y)) / 2.0f;

772
tools/assimp_view/Display.h
View File

@ -42,6 +42,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#if (!defined AV_DISPLAY_H_INCLUDED) #if (!defined AV_DISPLAY_H_INCLUDED)
#define AV_DISPLAY_H_INCLUDE #define AV_DISPLAY_H_INCLUDE
#include <windows.h>
#include <shellapi.h>
#include <commctrl.h>
// see CDisplay::m_aiImageList // see CDisplay::m_aiImageList
#define AI_VIEW_IMGLIST_NODE 0x0 #define AI_VIEW_IMGLIST_NODE 0x0
#define AI_VIEW_IMGLIST_MATERIAL 0x1 #define AI_VIEW_IMGLIST_MATERIAL 0x1
@ -49,486 +53,490 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define AI_VIEW_IMGLIST_TEXTURE_INVALID 0x3 #define AI_VIEW_IMGLIST_TEXTURE_INVALID 0x3
#define AI_VIEW_IMGLIST_MODEL 0x4 #define AI_VIEW_IMGLIST_MODEL 0x4
//------------------------------------------------------------------------------- namespace AssimpView
/* Corresponds to the "Display" combobox in the UI {
*/
//-------------------------------------------------------------------------------
class CDisplay
{
private:
// helper class //-------------------------------------------------------------------------------
struct Info /* Corresponds to the "Display" combobox in the UI
{ */
Info( D3DXVECTOR4* p1, //-------------------------------------------------------------------------------
AssetHelper::MeshHelper* p2, class CDisplay
const char* p3) {
: pclrColor(p1),pMesh(p2),szShaderParam(p3) {} private:
D3DXVECTOR4* pclrColor; // helper class
AssetHelper::MeshHelper* pMesh; struct Info
const char* szShaderParam; {
}; Info( D3DXVECTOR4* p1,
AssetHelper::MeshHelper* p2,
const char* p3 )
: pclrColor( p1 ), pMesh( p2 ), szShaderParam( p3 ) {}
// default constructor D3DXVECTOR4* pclrColor;
CDisplay() AssetHelper::MeshHelper* pMesh;
: m_iViewMode(VIEWMODE_FULL), const char* szShaderParam;
m_pcCurrentTexture(NULL), };
m_pcCurrentNode(NULL),
m_pcCurrentMaterial(NULL),
m_hImageList(NULL),
m_hRoot(NULL),
m_fTextureZoom(1000.0f)
{
this->m_aiImageList[0] = 0;
this->m_aiImageList[1] = 1;
this->m_aiImageList[2] = 2;
this->m_aiImageList[3] = 3;
this->m_aiImageList[4] = 4;
this->m_avCheckerColors[0].x = this->m_avCheckerColors[0].y = this->m_avCheckerColors[0].z = 0.4f; // default constructor
this->m_avCheckerColors[1].x = this->m_avCheckerColors[1].y = this->m_avCheckerColors[1].z = 0.6f; CDisplay()
} : m_iViewMode( VIEWMODE_FULL ),
m_pcCurrentTexture( NULL ),
m_pcCurrentNode( NULL ),
m_pcCurrentMaterial( NULL ),
m_hImageList( NULL ),
m_hRoot( NULL ),
m_fTextureZoom( 1000.0f )
{
this->m_aiImageList[ 0 ] = 0;
this->m_aiImageList[ 1 ] = 1;
this->m_aiImageList[ 2 ] = 2;
this->m_aiImageList[ 3 ] = 3;
this->m_aiImageList[ 4 ] = 4;
public: this->m_avCheckerColors[ 0 ].x = this->m_avCheckerColors[ 0 ].y = this->m_avCheckerColors[ 0 ].z = 0.4f;
this->m_avCheckerColors[ 1 ].x = this->m_avCheckerColors[ 1 ].y = this->m_avCheckerColors[ 1 ].z = 0.6f;
}
public:
//------------------------------------------------------------------ //------------------------------------------------------------------
enum enum
{ {
// the full model is displayed // the full model is displayed
VIEWMODE_FULL, VIEWMODE_FULL,
// a material is displayed on a simple spjere as model // a material is displayed on a simple spjere as model
VIEWMODE_MATERIAL, VIEWMODE_MATERIAL,
// a texture with an UV set mapped on it is displayed // a texture with an UV set mapped on it is displayed
VIEWMODE_TEXTURE, VIEWMODE_TEXTURE,
// a single node in the scenegraph is displayed // a single node in the scenegraph is displayed
VIEWMODE_NODE, VIEWMODE_NODE,
}; };
//------------------------------------------------------------------ //------------------------------------------------------------------
// represents a texture in the tree view // represents a texture in the tree view
struct TextureInfo struct TextureInfo
{ {
// texture info // texture info
IDirect3DTexture9** piTexture; IDirect3DTexture9** piTexture;
// Blend factor of the texture // Blend factor of the texture
float fBlend; float fBlend;
// blend operation for the texture // blend operation for the texture
aiTextureOp eOp; aiTextureOp eOp;
// UV index for the texture // UV index for the texture
unsigned int iUV; unsigned int iUV;
// Associated tree item // Associated tree item
HTREEITEM hTreeItem; HTREEITEM hTreeItem;
// Original path to the texture // Original path to the texture
std::string szPath; std::string szPath;
// index of the corresponding material // index of the corresponding material
unsigned int iMatIndex; unsigned int iMatIndex;
// type of the texture // type of the texture
unsigned int iType; unsigned int iType;
}; };
//------------------------------------------------------------------ //------------------------------------------------------------------
// represents a node in the tree view // represents a node in the tree view
struct NodeInfo struct NodeInfo
{ {
// node object // node object
aiNode* psNode; aiNode* psNode;
// corresponding tree view item // corresponding tree view item
HTREEITEM hTreeItem; HTREEITEM hTreeItem;
}; };
//------------------------------------------------------------------ //------------------------------------------------------------------
// represents a mesh in the tree view // represents a mesh in the tree view
struct MeshInfo struct MeshInfo
{ {
// the mesh object // the mesh object
aiMesh* psMesh; aiMesh* psMesh;
// corresponding tree view item // corresponding tree view item
HTREEITEM hTreeItem; HTREEITEM hTreeItem;
}; };
//------------------------------------------------------------------ //------------------------------------------------------------------
// represents a material in the tree view // represents a material in the tree view
struct MaterialInfo struct MaterialInfo
{ {
// material index // material index
unsigned int iIndex; unsigned int iIndex;
// material object // material object
aiMaterial* psMaterial; aiMaterial* psMaterial;
// ID3DXEffect interface // ID3DXEffect interface
ID3DXEffect* piEffect; ID3DXEffect* piEffect;
// corresponding tree view item // corresponding tree view item
HTREEITEM hTreeItem; HTREEITEM hTreeItem;
}; };
//------------------------------------------------------------------ //------------------------------------------------------------------
// Singleton accessors // Singleton accessors
static CDisplay s_cInstance; static CDisplay s_cInstance;
inline static CDisplay& Instance () inline static CDisplay& Instance()
{ {
return s_cInstance; return s_cInstance;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// Called during the render loop. Renders the scene (including the // Called during the render loop. Renders the scene (including the
// HUD etc) in the current view mode // HUD etc) in the current view mode
int OnRender(); int OnRender();
//------------------------------------------------------------------ //------------------------------------------------------------------
// called when the user selects another item in the "Display" tree // called when the user selects another item in the "Display" tree
// view the method determines the new view mode and performs all // view the method determines the new view mode and performs all
// required operations // required operations
// \param p_hTreeItem Selected tree view item // \param p_hTreeItem Selected tree view item
int OnSetup(HTREEITEM p_hTreeItem); int OnSetup( HTREEITEM p_hTreeItem );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Variant 1: Render the full scene with the asset // Variant 1: Render the full scene with the asset
int RenderFullScene(); int RenderFullScene();
#if 0 #if 0
//------------------------------------------------------------------ //------------------------------------------------------------------
// Variant 2: Render only a part of the scene. One node to // Variant 2: Render only a part of the scene. One node to
// be exact // be exact
int RenderScenePart(); int RenderScenePart();
#endif #endif
//------------------------------------------------------------------ //------------------------------------------------------------------
// Variant 3: Render a large sphere and map a given material on it // Variant 3: Render a large sphere and map a given material on it
int RenderMaterialView(); int RenderMaterialView();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Variant 4: Render a flat plane, map a texture on it and // Variant 4: Render a flat plane, map a texture on it and
// display the UV wire on it // display the UV wire on it
int RenderTextureView(); int RenderTextureView();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Fill the UI combobox with a list of all supported view modi // Fill the UI combobox with a list of all supported view modi
// //
// The display modes are added in order // The display modes are added in order
int FillDisplayList(void); int FillDisplayList( void );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Add a material and all sub textures to the display mode list // Add a material and all sub textures to the display mode list
// hRoot - Handle to the root of the tree view // hRoot - Handle to the root of the tree view
// iIndex - Material index // iIndex - Material index
int AddMaterialToDisplayList(HTREEITEM hRoot, int AddMaterialToDisplayList( HTREEITEM hRoot,
unsigned int iIndex); unsigned int iIndex );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Add a texture to the display list // Add a texture to the display list
// pcMat - material containing the texture // pcMat - material containing the texture
// hTexture - Handle to the material tree item // hTexture - Handle to the material tree item
// szPath - Path to the texture // szPath - Path to the texture
// iUVIndex - UV index to be used for the texture // iUVIndex - UV index to be used for the texture
// fBlendFactor - Blend factor to be used for the texture // fBlendFactor - Blend factor to be used for the texture
// eTextureOp - texture operation to be used for the texture // eTextureOp - texture operation to be used for the texture
int AddTextureToDisplayList(unsigned int iType, int AddTextureToDisplayList( unsigned int iType,
unsigned int iIndex, unsigned int iIndex,
const aiString* szPath, const aiString* szPath,
HTREEITEM hFX, HTREEITEM hFX,
unsigned int iUVIndex = 0, unsigned int iUVIndex = 0,
const float fBlendFactor = 0.0f, const float fBlendFactor = 0.0f,
aiTextureOp eTextureOp = aiTextureOp_Multiply, aiTextureOp eTextureOp = aiTextureOp_Multiply,
unsigned int iMesh = 0); unsigned int iMesh = 0 );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Add a node to the display list // Add a node to the display list
// Recusrivly adds all subnodes as well // Recusrivly adds all subnodes as well
// iIndex - Index of the node in the parent's child list // iIndex - Index of the node in the parent's child list
// iDepth - Current depth of the node // iDepth - Current depth of the node
// pcNode - Node object // pcNode - Node object
// hRoot - Parent tree view node // hRoot - Parent tree view node
int AddNodeToDisplayList( int AddNodeToDisplayList(
unsigned int iIndex, unsigned int iIndex,
unsigned int iDepth, unsigned int iDepth,
aiNode* pcNode, aiNode* pcNode,
HTREEITEM hRoot); HTREEITEM hRoot );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Add a mesh to the display list // Add a mesh to the display list
// iIndex - Index of the mesh in the scene's mesh list // iIndex - Index of the mesh in the scene's mesh list
// hRoot - Parent tree view node // hRoot - Parent tree view node
int AddMeshToDisplayList( int AddMeshToDisplayList(
unsigned int iIndex, unsigned int iIndex,
HTREEITEM hRoot); HTREEITEM hRoot );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Load the image list for the tree view item // Load the image list for the tree view item
int LoadImageList(void); int LoadImageList( void );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Expand all nodes in the tree // Expand all nodes in the tree
int ExpandTree(); int ExpandTree();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Fill the UI combobox with a list of all supported animations // Fill the UI combobox with a list of all supported animations
// The animations are added in order // The animations are added in order
int FillAnimList(void); int FillAnimList( void );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Clear the combox box containing the list of animations // Clear the combox box containing the list of animations
int ClearAnimList(void); int ClearAnimList( void );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Clear the combox box containing the list of scenegraph items // Clear the combox box containing the list of scenegraph items
int ClearDisplayList(void); int ClearDisplayList( void );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Fill in the default statistics // Fill in the default statistics
int FillDefaultStatistics(void); int FillDefaultStatistics( void );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Called by LoadAsset() // Called by LoadAsset()
// reset the class instance to the default values // reset the class instance to the default values
int Reset(void); int Reset( void );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Replace the texture that is current selected with // Replace the texture that is current selected with
// a new texture // a new texture
int ReplaceCurrentTexture(const char* szPath); int ReplaceCurrentTexture( const char* szPath );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Display the context menu (if there) for the specified tree item // Display the context menu (if there) for the specified tree item
// hItem Valid tree view item handle // hItem Valid tree view item handle
int ShowTreeViewContextMenu(HTREEITEM hItem); int ShowTreeViewContextMenu( HTREEITEM hItem );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Event handling for pop-up menus displayed by th tree view // Event handling for pop-up menus displayed by th tree view
int HandleTreeViewPopup(WPARAM wParam,LPARAM lParam); int HandleTreeViewPopup( WPARAM wParam, LPARAM lParam );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Enable animation-related parts of the UI // Enable animation-related parts of the UI
int EnableAnimTools(BOOL hm) ; int EnableAnimTools( BOOL hm );
//------------------------------------------------------------------ //------------------------------------------------------------------
// setter for m_iViewMode // setter for m_iViewMode
inline void SetViewMode(unsigned int p_iNew) inline void SetViewMode( unsigned int p_iNew )
{ {
this->m_iViewMode = p_iNew; this->m_iViewMode = p_iNew;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// getter for m_iViewMode // getter for m_iViewMode
inline unsigned int GetViewMode() inline unsigned int GetViewMode()
{ {
return m_iViewMode; return m_iViewMode;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// change the texture view's zoom factor // change the texture view's zoom factor
inline void SetTextureViewZoom(float f) inline void SetTextureViewZoom( float f )
{ {
// FIX: Removed log(), seems to make more problems than it fixes // FIX: Removed log(), seems to make more problems than it fixes
this->m_fTextureZoom += f* 15; this->m_fTextureZoom += f * 15;
if (this->m_fTextureZoom < 0.05f)this->m_fTextureZoom = 0.05f; if( this->m_fTextureZoom < 0.05f )this->m_fTextureZoom = 0.05f;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// change the texture view's offset on the x axis // change the texture view's offset on the x axis
inline void SetTextureViewOffsetX(float f) inline void SetTextureViewOffsetX( float f )
{ {
this->m_vTextureOffset.x += f; this->m_vTextureOffset.x += f;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// change the texture view's offset on the y axis // change the texture view's offset on the y axis
inline void SetTextureViewOffsetY(float f) inline void SetTextureViewOffsetY( float f )
{ {
this->m_vTextureOffset.y += f; this->m_vTextureOffset.y += f;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// add a new texture to the list // add a new texture to the list
inline void AddTexture(const TextureInfo& info) inline void AddTexture( const TextureInfo& info )
{ {
this->m_asTextures.push_back(info); this->m_asTextures.push_back( info );
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// add a new node to the list // add a new node to the list
inline void AddNode(const NodeInfo& info) inline void AddNode( const NodeInfo& info )
{ {
this->m_asNodes.push_back(info); this->m_asNodes.push_back( info );
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// add a new mesh to the list // add a new mesh to the list
inline void AddMesh(const MeshInfo& info) inline void AddMesh( const MeshInfo& info )
{ {
this->m_asMeshes.push_back(info); this->m_asMeshes.push_back( info );
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// add a new material to the list // add a new material to the list
inline void AddMaterial(const MaterialInfo& info) inline void AddMaterial( const MaterialInfo& info )
{ {
this->m_asMaterials.push_back(info); this->m_asMaterials.push_back( info );
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// set the primary color of the checker pattern background // set the primary color of the checker pattern background
inline void SetFirstCheckerColor(D3DXVECTOR4 c) inline void SetFirstCheckerColor( D3DXVECTOR4 c )
{ {
this->m_avCheckerColors[0] = c; this->m_avCheckerColors[ 0 ] = c;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// set the secondary color of the checker pattern background // set the secondary color of the checker pattern background
inline void SetSecondCheckerColor(D3DXVECTOR4 c) inline void SetSecondCheckerColor( D3DXVECTOR4 c )
{ {
this->m_avCheckerColors[1] = c; this->m_avCheckerColors[ 1 ] = c;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// get the primary color of the checker pattern background // get the primary color of the checker pattern background
inline const D3DXVECTOR4* GetFirstCheckerColor() const inline const D3DXVECTOR4* GetFirstCheckerColor() const
{ {
return &this->m_avCheckerColors[0]; return &this->m_avCheckerColors[ 0 ];
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// get the secondary color of the checker pattern background // get the secondary color of the checker pattern background
inline const D3DXVECTOR4* GetSecondCheckerColor() const inline const D3DXVECTOR4* GetSecondCheckerColor() const
{ {
return &this->m_avCheckerColors[1]; return &this->m_avCheckerColors[ 1 ];
} }
private: private:
//------------------------------------------------------------------ //------------------------------------------------------------------
// Render a screen-filling square using the checker pattern shader // Render a screen-filling square using the checker pattern shader
int RenderPatternBG(); int RenderPatternBG();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Render a given node in the scenegraph // Render a given node in the scenegraph
// piNode Node to be rendered // piNode Node to be rendered
// piMatrix Current transformation matrix // piMatrix Current transformation matrix
// bAlpha Render alpha or opaque objects only? // bAlpha Render alpha or opaque objects only?
int RenderNode (aiNode* piNode,const aiMatrix4x4& piMatrix, int RenderNode( aiNode* piNode, const aiMatrix4x4& piMatrix,
bool bAlpha = false); bool bAlpha = false );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Setup the camera for the stereo view rendering mode // Setup the camera for the stereo view rendering mode
int SetupStereoView(); int SetupStereoView();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Render the second view (for the right eye) in stereo mod // Render the second view (for the right eye) in stereo mod
// m - World matrix // m - World matrix
int RenderStereoView(const aiMatrix4x4& m); int RenderStereoView( const aiMatrix4x4& m );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Handle user input // Handle user input
int HandleInput(); int HandleInput();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Handle user input for the texture viewer // Handle user input for the texture viewer
int HandleInputTextureView(); int HandleInputTextureView();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Handle user input if no asset is loaded // Handle user input if no asset is loaded
int HandleInputEmptyScene(); int HandleInputEmptyScene();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Draw the HUD (call only if FPS mode isn't active) // Draw the HUD (call only if FPS mode isn't active)
int DrawHUD(); int DrawHUD();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Used by OnSetup(). // Used by OnSetup().
// Do everything necessary to switch to texture view mode // Do everything necessary to switch to texture view mode
int OnSetupTextureView(TextureInfo* pcNew); int OnSetupTextureView( TextureInfo* pcNew );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Used by OnSetup(). // Used by OnSetup().
// Do everything necessary to switch to material view mode // Do everything necessary to switch to material view mode
int OnSetupMaterialView(MaterialInfo* pcNew); int OnSetupMaterialView( MaterialInfo* pcNew );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Used by OnSetup(). // Used by OnSetup().
// Do everything necessary to switch to node view mode // Do everything necessary to switch to node view mode
int OnSetupNodeView(NodeInfo* pcNew); int OnSetupNodeView( NodeInfo* pcNew );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Used by OnSetup(). // Used by OnSetup().
// Do everything necessary to switch back to normal view mode // Do everything necessary to switch back to normal view mode
int OnSetupNormalView(); int OnSetupNormalView();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Used by HandleTreeViewPopup(). // Used by HandleTreeViewPopup().
int HandleTreeViewPopup2(WPARAM wParam,LPARAM lParam); int HandleTreeViewPopup2( WPARAM wParam, LPARAM lParam );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Render skeleton // Render skeleton
int RenderSkeleton (aiNode* piNode,const aiMatrix4x4& piMatrix, int RenderSkeleton( aiNode* piNode, const aiMatrix4x4& piMatrix,
const aiMatrix4x4& parent); const aiMatrix4x4& parent );
private: private:
// view mode // view mode
unsigned int m_iViewMode; unsigned int m_iViewMode;
// List of all textures in the display CB // List of all textures in the display CB
std::vector<TextureInfo> m_asTextures; std::vector<TextureInfo> m_asTextures;
// current texture or NULL if no texture is active // current texture or NULL if no texture is active
TextureInfo* m_pcCurrentTexture; TextureInfo* m_pcCurrentTexture;
// List of all node in the display CB // List of all node in the display CB
std::vector<NodeInfo> m_asNodes; std::vector<NodeInfo> m_asNodes;
// List of all node in the display CB // List of all node in the display CB
std::vector<MeshInfo> m_asMeshes; std::vector<MeshInfo> m_asMeshes;
// current Node or NULL if no Node is active // current Node or NULL if no Node is active
NodeInfo* m_pcCurrentNode; NodeInfo* m_pcCurrentNode;
// List of all materials in the display CB // List of all materials in the display CB
std::vector<MaterialInfo> m_asMaterials; std::vector<MaterialInfo> m_asMaterials;
// current material or NULL if no material is active // current material or NULL if no material is active
MaterialInfo* m_pcCurrentMaterial; MaterialInfo* m_pcCurrentMaterial;
// indices into the image list of the "display" tree view control // indices into the image list of the "display" tree view control
unsigned int m_aiImageList[5]; /* = {0,1,2,3,4};*/ unsigned int m_aiImageList[ 5 ]; /* = {0,1,2,3,4};*/
// Image list // Image list
HIMAGELIST m_hImageList; HIMAGELIST m_hImageList;
// Root node of the tree, "Model" // Root node of the tree, "Model"
HTREEITEM m_hRoot; HTREEITEM m_hRoot;
// Current zoom factor of the texture viewer // Current zoom factor of the texture viewer
float m_fTextureZoom; float m_fTextureZoom;
// Current offset (in pixels) of the texture viewer // Current offset (in pixels) of the texture viewer
aiVector2D m_vTextureOffset; aiVector2D m_vTextureOffset;
// Colors used to draw the checker pattern (for the // Colors used to draw the checker pattern (for the
// texture viewer as background ) // texture viewer as background )
D3DXVECTOR4 m_avCheckerColors[2]; D3DXVECTOR4 m_avCheckerColors[ 2 ];
// View projection matrix // View projection matrix
aiMatrix4x4 mViewProjection; aiMatrix4x4 mViewProjection;
aiVector3D vPos; aiVector3D vPos;
}; };
}
#endif // AV_DISPLAY_H_INCLUDE #endif // AV_DISPLAY_H_INCLUDE

2
tools/assimp_view/HelpDialog.cpp
View File

@ -39,14 +39,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#include "stdafx.h"
#include "assimp_view.h" #include "assimp_view.h"
#include "richedit.h" #include "richedit.h"
namespace AssimpView { namespace AssimpView {
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
// Message procedure for the help dialog // Message procedure for the help dialog
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------

2
tools/assimp_view/Input.cpp
View File

@ -39,10 +39,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#include "stdafx.h"
#include "assimp_view.h" #include "assimp_view.h"
namespace AssimpView { namespace AssimpView {
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------

5
tools/assimp_view/LogDisplay.cpp
View File

@ -39,14 +39,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#include "stdafx.h"
#include "assimp_view.h" #include "assimp_view.h"
namespace AssimpView { namespace AssimpView {
CLogDisplay CLogDisplay::s_cInstance;
/* extern */ CLogDisplay CLogDisplay::s_cInstance;
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
void CLogDisplay::AddEntry(const std::string& szText, void CLogDisplay::AddEntry(const std::string& szText,

87
tools/assimp_view/LogDisplay.h
View File

@ -38,59 +38,62 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#pragma once
#if (!defined AV_LOG_DISPLAY_H_INCLUDED) #include <list>
#define AV_LOG_DISPLAY_H_INCLUDE
//------------------------------------------------------------------------------- namespace AssimpView
/** \brief Class to display log strings in the upper right corner of the view {
*/
//-------------------------------------------------------------------------------
class CLogDisplay
{
private:
CLogDisplay() {} //-------------------------------------------------------------------------------
/** \brief Class to display log strings in the upper right corner of the view
*/
//-------------------------------------------------------------------------------
class CLogDisplay
{
private:
public: CLogDisplay() {}
// data structure for an entry in the log queue public:
struct SEntry
{
SEntry ()
:
clrColor(D3DCOLOR_ARGB(0xFF,0xFF,0xFF,0x00)), dwStartTicks(0)
{}
std::string szText; // data structure for an entry in the log queue
D3DCOLOR clrColor; struct SEntry
DWORD dwStartTicks; {
}; SEntry()
:
clrColor( D3DCOLOR_ARGB( 0xFF, 0xFF, 0xFF, 0x00 ) ), dwStartTicks( 0 )
{}
// Singleton accessors std::string szText;
static CLogDisplay s_cInstance; D3DCOLOR clrColor;
inline static CLogDisplay& Instance () DWORD dwStartTicks;
{ };
return s_cInstance;
}
// Add an entry to the log queue // Singleton accessors
void AddEntry(const std::string& szText, static CLogDisplay s_cInstance;
const D3DCOLOR clrColor = D3DCOLOR_ARGB(0xFF,0xFF,0xFF,0x00)); inline static CLogDisplay& Instance()
{
return s_cInstance;
}
// Release any native resources associated with the instance // Add an entry to the log queue
void ReleaseNativeResource(); void AddEntry( const std::string& szText,
const D3DCOLOR clrColor = D3DCOLOR_ARGB( 0xFF, 0xFF, 0xFF, 0x00 ) );
// Recreate any native resources associated with the instance // Release any native resources associated with the instance
void RecreateNativeResource(); void ReleaseNativeResource();
// Called during the render loop // Recreate any native resources associated with the instance
void OnRender(); void RecreateNativeResource();
private: // Called during the render loop
void OnRender();
std::list<SEntry> asEntries; private:
ID3DXFont* piFont;
};
#endif // AV_LOG_DISPLAY_H_INCLUDE std::list<SEntry> asEntries;
ID3DXFont* piFont;
};
}

4
tools/assimp_view/LogWindow.cpp
View File

@ -39,13 +39,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#include "stdafx.h"
#include "assimp_view.h" #include "assimp_view.h"
#include "richedit.h" #include "richedit.h"
namespace AssimpView { namespace AssimpView {
/* extern */ CLogWindow CLogWindow::s_cInstance; CLogWindow CLogWindow::s_cInstance;
extern HKEY g_hRegistry; extern HKEY g_hRegistry;
// header for the RTF log file // header for the RTF log file

149
tools/assimp_view/LogWindow.h
View File

@ -42,87 +42,92 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#if (!defined AV_LOG_WINDOW_H_INCLUDED) #if (!defined AV_LOG_WINDOW_H_INCLUDED)
#define AV_LOG_WINDOW_H_INCLUDE #define AV_LOG_WINDOW_H_INCLUDE
namespace AssimpView
//-------------------------------------------------------------------------------
/** \brief Subclass of Assimp::LogStream used to add all log messages to the
* log window.
*/
//-------------------------------------------------------------------------------
class CMyLogStream : public Assimp::LogStream
{ {
public:
/** @brief Implementation of the abstract method */
void write(const char* message);
};
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
/** \brief Class to display log strings in a separate window /** \brief Subclass of Assimp::LogStream used to add all log messages to the
*/ * log window.
//------------------------------------------------------------------------------- */
class CLogWindow //-------------------------------------------------------------------------------
{ class CMyLogStream : public Assimp::LogStream
private: {
public:
friend class CMyLogStream; /** @brief Implementation of the abstract method */
friend INT_PTR CALLBACK LogDialogProc(HWND hwndDlg,UINT uMsg, void write( const char* message );
WPARAM wParam,LPARAM lParam); };
CLogWindow() : hwnd(NULL), bIsVisible(false), bUpdate(true) {}
public:
// Singleton accessors //-------------------------------------------------------------------------------
static CLogWindow s_cInstance; /** \brief Class to display log strings in a separate window
inline static CLogWindow& Instance () */
{ //-------------------------------------------------------------------------------
return s_cInstance; class CLogWindow
} {
private:
// initializes the log window friend class CMyLogStream;
void Init (); friend INT_PTR CALLBACK LogDialogProc( HWND hwndDlg, UINT uMsg,
WPARAM wParam, LPARAM lParam );
// Shows the log window CLogWindow() : hwnd( NULL ), bIsVisible( false ), bUpdate( true ) {}
void Show();
// Clears the log window public:
void Clear();
// Save the log window to an user-defined file
void Save();
// write a line to the log window
void WriteLine(const char* message);
// Set the bUpdate member
inline void SetAutoUpdate(bool b)
{
this->bUpdate = b;
}
// updates the log file
void Update();
private:
// Window handle
HWND hwnd;
// current text of the window (contains RTF tags)
std::string szText;
std::string szPlainText;
// is the log window currently visible?
bool bIsVisible;
// Specified whether each new log message updates the log automatically
bool bUpdate;
public: // Singleton accessors
// associated log stream static CLogWindow s_cInstance;
CMyLogStream* pcStream; inline static CLogWindow& Instance()
}; {
return s_cInstance;
}
// initializes the log window
void Init();
// Shows the log window
void Show();
// Clears the log window
void Clear();
// Save the log window to an user-defined file
void Save();
// write a line to the log window
void WriteLine( const char* message );
// Set the bUpdate member
inline void SetAutoUpdate( bool b )
{
this->bUpdate = b;
}
// updates the log file
void Update();
private:
// Window handle
HWND hwnd;
// current text of the window (contains RTF tags)
std::string szText;
std::string szPlainText;
// is the log window currently visible?
bool bIsVisible;
// Specified whether each new log message updates the log automatically
bool bUpdate;
public:
// associated log stream
CMyLogStream* pcStream;
};
}
#endif // AV_LOG_DISPLA #endif // AV_LOG_DISPLA

2409
tools/assimp_view/Material.cpp
View File

File diff suppressed because it is too large Load Diff

276
tools/assimp_view/MaterialManager.h
View File

@ -39,164 +39,170 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#if (!defined AV_MATERIAL_H_INCLUDED) #pragma once
#define AV_MATERIAL_H_INCLUDE
//------------------------------------------------------------------------------- #include <map>
/* Helper class to create, access and destroy materials
*/ #include "AssetHelper.h"
//-------------------------------------------------------------------------------
class CMaterialManager namespace AssimpView
{ {
private:
friend class CDisplay; //-------------------------------------------------------------------------------
/* Helper class to create, access and destroy materials
*/
//-------------------------------------------------------------------------------
class CMaterialManager
{
private:
// default constructor friend class CDisplay;
CMaterialManager()
: m_iShaderCount (0), sDefaultTexture() {}
~CMaterialManager() { // default constructor
if (sDefaultTexture) { CMaterialManager()
sDefaultTexture->Release(); : m_iShaderCount( 0 ), sDefaultTexture() {}
}
Reset();
}
public: ~CMaterialManager() {
if( sDefaultTexture ) {
sDefaultTexture->Release();
}
Reset();
}
//------------------------------------------------------------------ public:
// Singleton accessors
static CMaterialManager s_cInstance;
inline static CMaterialManager& Instance ()
{
return s_cInstance;
}
//------------------------------------------------------------------ //------------------------------------------------------------------
// Delete all resources of a given material // Singleton accessors
// static CMaterialManager s_cInstance;
// Must be called before CreateMaterial() to prevent memory leaking inline static CMaterialManager& Instance()
void DeleteMaterial(AssetHelper::MeshHelper* pcIn); {
return s_cInstance;
}
//------------------------------------------------------------------ //------------------------------------------------------------------
// Create the material for a mesh. // Delete all resources of a given material
// //
// The function checks whether an identical shader is already in use. // Must be called before CreateMaterial() to prevent memory leaking
// A shader is considered to be identical if it has the same input void DeleteMaterial( AssetHelper::MeshHelper* pcIn );
// signature and takes the same number of texture channels.
int CreateMaterial(AssetHelper::MeshHelper* pcMesh,
const aiMesh* pcSource);
//------------------------------------------------------------------ //------------------------------------------------------------------
// Setup the material for a given mesh // Create the material for a mesh.
// pcMesh Mesh to be rendered //
// pcProj Projection matrix // The function checks whether an identical shader is already in use.
// aiMe Current world matrix // A shader is considered to be identical if it has the same input
// pcCam Camera matrix // signature and takes the same number of texture channels.
// vPos Position of the camera int CreateMaterial( AssetHelper::MeshHelper* pcMesh,
// TODO: Extract camera position from matrix ... const aiMesh* pcSource );
//
int SetupMaterial (AssetHelper::MeshHelper* pcMesh,
const aiMatrix4x4& pcProj,
const aiMatrix4x4& aiMe,
const aiMatrix4x4& pcCam,
const aiVector3D& vPos);
//------------------------------------------------------------------ //------------------------------------------------------------------
// End the material for a given mesh // Setup the material for a given mesh
// Called after mesh rendering is complete // pcMesh Mesh to be rendered
// pcMesh Mesh object // pcProj Projection matrix
int EndMaterial (AssetHelper::MeshHelper* pcMesh); // aiMe Current world matrix
// pcCam Camera matrix
// vPos Position of the camera
// TODO: Extract camera position from matrix ...
//
int SetupMaterial( AssetHelper::MeshHelper* pcMesh,
const aiMatrix4x4& pcProj,
const aiMatrix4x4& aiMe,
const aiMatrix4x4& pcCam,
const aiVector3D& vPos );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Recreate all specular materials depending on the current // End the material for a given mesh
// specularity settings // Called after mesh rendering is complete
// // pcMesh Mesh object
// Diffuse-only materials are ignored. int EndMaterial( AssetHelper::MeshHelper* pcMesh );
// Must be called after specular highlights have been toggled
int UpdateSpecularMaterials();
//------------------------------------------------------------------ //------------------------------------------------------------------
// find a valid path to a texture file // Recreate all specular materials depending on the current
// // specularity settings
// Handle 8.3 syntax correctly, search the environment of the //
// executable and the asset for a texture with a name very similar // Diffuse-only materials are ignored.
// to a given one // Must be called after specular highlights have been toggled
int FindValidPath(aiString* p_szString); int UpdateSpecularMaterials();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Load a texture into memory and create a native D3D texture resource // find a valid path to a texture file
// //
// The function tries to find a valid path for a texture // Handle 8.3 syntax correctly, search the environment of the
int LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath); // executable and the asset for a texture with a name very similar
// to a given one
int FindValidPath( aiString* p_szString );
//------------------------------------------------------------------
// Load a texture into memory and create a native D3D texture resource
//
// The function tries to find a valid path for a texture
int LoadTexture( IDirect3DTexture9** p_ppiOut, aiString* szPath );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Getter for m_iShaderCount // Getter for m_iShaderCount
// //
inline unsigned int GetShaderCount() inline unsigned int GetShaderCount()
{ {
return this->m_iShaderCount; return this->m_iShaderCount;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// Reset the state of the class // Reset the state of the class
// Called whenever a new asset is loaded // Called whenever a new asset is loaded
inline void Reset() inline void Reset()
{ {
this->m_iShaderCount = 0; this->m_iShaderCount = 0;
for (TextureCache::iterator it = sCachedTextures.begin(); it != sCachedTextures.end(); ++it) { for( TextureCache::iterator it = sCachedTextures.begin(); it != sCachedTextures.end(); ++it ) {
(*it).second->Release(); ( *it ).second->Release();
} }
sCachedTextures.clear(); sCachedTextures.clear();
} }
private: private:
//------------------------------------------------------------------ //------------------------------------------------------------------
// find a valid path to a texture file // find a valid path to a texture file
// //
// Handle 8.3 syntax correctly, search the environment of the // Handle 8.3 syntax correctly, search the environment of the
// executable and the asset for a texture with a name very similar // executable and the asset for a texture with a name very similar
// to a given one // to a given one
bool TryLongerPath(char* szTemp,aiString* p_szString); bool TryLongerPath( char* szTemp, aiString* p_szString );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Setup the default texture for a texture channel // Setup the default texture for a texture channel
// //
// Generates a default checker pattern for a texture // Generates a default checker pattern for a texture
int SetDefaultTexture(IDirect3DTexture9** p_ppiOut); int SetDefaultTexture( IDirect3DTexture9** p_ppiOut );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Convert a height map to a normal map if necessary // Convert a height map to a normal map if necessary
// //
// The function tries to detect the type of a texture automatically. // The function tries to detect the type of a texture automatically.
// However, this wont work in every case. // However, this wont work in every case.
void HMtoNMIfNecessary(IDirect3DTexture9* piTexture, void HMtoNMIfNecessary( IDirect3DTexture9* piTexture,
IDirect3DTexture9** piTextureOut, IDirect3DTexture9** piTextureOut,
bool bWasOriginallyHM = true); bool bWasOriginallyHM = true );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Search for non-opaque pixels in a texture // Search for non-opaque pixels in a texture
// //
// A pixel is considered to be non-opaque if its alpha value is // A pixel is considered to be non-opaque if its alpha value is
// less than 255 // less than 255
//------------------------------------------------------------------ //------------------------------------------------------------------
bool HasAlphaPixels(IDirect3DTexture9* piTexture); bool HasAlphaPixels( IDirect3DTexture9* piTexture );
private: private:
// //
// Specifies the number of different shaders generated for // Specifies the number of different shaders generated for
// the current asset. This number is incremented by CreateMaterial() // the current asset. This number is incremented by CreateMaterial()
// each time a shader isn't found in cache and needs to be created // each time a shader isn't found in cache and needs to be created
// //
unsigned int m_iShaderCount; unsigned int m_iShaderCount;
IDirect3DTexture9* sDefaultTexture; IDirect3DTexture9* sDefaultTexture;
typedef std::map<std::string,IDirect3DTexture9*> TextureCache; typedef std::map<std::string, IDirect3DTexture9*> TextureCache;
TextureCache sCachedTextures; TextureCache sCachedTextures;
}; };
#endif //!! include guard }

2
tools/assimp_view/MeshRenderer.cpp
View File

@ -39,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#include "stdafx.h"
#include "assimp_view.h" #include "assimp_view.h"
#include <map> #include <map>
@ -47,7 +46,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
namespace AssimpView { namespace AssimpView {
CMeshRenderer CMeshRenderer::s_cInstance; CMeshRenderer CMeshRenderer::s_cInstance;
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------

76
tools/assimp_view/MeshRenderer.h
View File

@ -42,56 +42,58 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#if (!defined AV_MESH_RENDERER_H_INCLUDED) #if (!defined AV_MESH_RENDERER_H_INCLUDED)
#define AV_MESH_RENDERER_H_INCLUDED #define AV_MESH_RENDERER_H_INCLUDED
namespace AssimpView {
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
/* Helper class tp render meshes /* Helper class tp render meshes
*/ */
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
class CMeshRenderer class CMeshRenderer
{ {
private: private:
// default constructor // default constructor
CMeshRenderer() CMeshRenderer()
{ {
// no other members to initialize // no other members to initialize
} }
public: public:
//------------------------------------------------------------------ //------------------------------------------------------------------
// Singleton accessors // Singleton accessors
static CMeshRenderer s_cInstance; static CMeshRenderer s_cInstance;
inline static CMeshRenderer& Instance () inline static CMeshRenderer& Instance()
{ {
return s_cInstance; return s_cInstance;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// Draw a mesh in the global mesh list using the current pipeline state // Draw a mesh in the global mesh list using the current pipeline state
// iIndex Index of the mesh to be drawn // iIndex Index of the mesh to be drawn
// //
// The function draws all faces in order, regardless of their distance // The function draws all faces in order, regardless of their distance
int DrawUnsorted(unsigned int iIndex); int DrawUnsorted( unsigned int iIndex );
//------------------------------------------------------------------ //------------------------------------------------------------------
// Draw a mesh in the global mesh list using the current pipeline state // Draw a mesh in the global mesh list using the current pipeline state
// iIndex Index of the mesh to be drawn // iIndex Index of the mesh to be drawn
// //
// The method sorts all vertices by their distance (back to front) // The method sorts all vertices by their distance (back to front)
// //
// mWorld World matrix for the node // mWorld World matrix for the node
int DrawSorted(unsigned int iIndex, int DrawSorted( unsigned int iIndex,
const aiMatrix4x4& mWorld); const aiMatrix4x4& mWorld );
private: private:
}; };
}
#endif //!! include guard #endif //!! include guard

10
tools/assimp_view/MessageProc.cpp
View File

@ -39,12 +39,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
#include "stdafx.h"
#include "assimp_view.h" #include "assimp_view.h"
#include <assimp/Exporter.hpp>
#include <algorithm>
#include <windowsx.h> #include <windowsx.h>
namespace AssimpView { namespace AssimpView {
using namespace Assimp;
// Static array to keep custom color values // Static array to keep custom color values
COLORREF g_aclCustomColors[16] = {0}; COLORREF g_aclCustomColors[16] = {0};
@ -1044,9 +1048,9 @@ void DoExport(size_t formatId)
ai_assert(strlen(szFileName) <= MAX_PATH); ai_assert(strlen(szFileName) <= MAX_PATH);
// invent a nice default file name // invent a nice default file name
char* sz = std::max(strrchr(szFileName,'\\'),strrchr(szFileName,'/')); char* sz = max(strrchr(szFileName,'\\'),strrchr(szFileName,'/'));
if (sz) { if (sz) {
strncpy(sz,std::max(strrchr(g_szFileName,'\\'),strrchr(g_szFileName,'/')),MAX_PATH); strncpy(sz,max(strrchr(g_szFileName,'\\'),strrchr(g_szFileName,'/')),MAX_PATH);
} }
} }
else { else {

2
tools/assimp_view/Normals.cpp
View File

@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "stdafx.h"
#include "assimp_view.h" #include "assimp_view.h"
// note: these are no longer part of the public API, but they are // note: these are no longer part of the public API, but they are
@ -53,6 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
namespace AssimpView { namespace AssimpView {
using namespace Assimp;
bool g_bWasFlipped = false; bool g_bWasFlipped = false;
float g_smoothAngle = 80.f; float g_smoothAngle = 80.f;

1
tools/assimp_view/SceneAnimator.cpp
View File

@ -43,7 +43,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @brief Implementation of the utility class SceneAnimator * @brief Implementation of the utility class SceneAnimator
*/ */
#include "stdafx.h"
#include "assimp_view.h" #include "assimp_view.h"
using namespace AssimpView; using namespace AssimpView;

2482
tools/assimp_view/Shaders.cpp
View File

File diff suppressed because it is too large Load Diff

1597
tools/assimp_view/assimp_view.cpp
View File

File diff suppressed because it is too large Load Diff

67
tools/assimp_view/assimp_view.h
View File

@ -47,6 +47,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// include resource definitions // include resource definitions
#include "resource.h" #include "resource.h"
#include <assert.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <time.h>
// Include ASSIMP headers (XXX: do we really need all of them?) // Include ASSIMP headers (XXX: do we really need all of them?)
#include <assimp/cimport.h> #include <assimp/cimport.h>
#include <assimp/Importer.hpp> #include <assimp/Importer.hpp>
@ -59,29 +67,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/LogStream.hpp> #include <assimp/LogStream.hpp>
#include <assimp/DefaultLogger.hpp> #include <assimp/DefaultLogger.hpp>
#include "../../code/AssimpPCH.h" /* HACK */
#include "../../code/MaterialSystem.h" // aiMaterial class #include "../../code/MaterialSystem.h" // aiMaterial class
#include "../../code/StringComparison.h" // ASSIMP_stricmp and ASSIMP_strincmp #include "../../code/StringComparison.h" // ASSIMP_stricmp and ASSIMP_strincmp
// in order for std::min and std::max to behave properly // in order for std::min and std::max to behave properly
#ifdef min /*#ifdef min
#undef min #undef min
#endif // min #endif // min
#ifdef max #ifdef max
#undef max #undef max
#endif // min #endif // min*/
#include <time.h> #include <time.h>
// default movement speed // default movement speed
#define MOVE_SPEED 3.f #define MOVE_SPEED 3.f
using namespace Assimp;
namespace AssimpView
{
#include "AssetHelper.h" #include "AssetHelper.h"
#include "Camera.h" #include "Camera.h"
#include "RenderOptions.h" #include "RenderOptions.h"
@ -93,7 +95,6 @@ namespace AssimpView
#include "MeshRenderer.h" #include "MeshRenderer.h"
#include "MaterialManager.h" #include "MaterialManager.h"
} // end of namespace AssimpView - for a while
// outside of namespace, to help Intellisense and solve boost::metatype_stuff_miracle // outside of namespace, to help Intellisense and solve boost::metatype_stuff_miracle
#include "AnimEvaluator.h" #include "AnimEvaluator.h"
@ -105,30 +106,30 @@ namespace AssimpView
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
// Function prototypes // Function prototypes
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
int InitD3D(void); int InitD3D(void);
int ShutdownD3D(void); int ShutdownD3D(void);
int CreateDevice (bool p_bMultiSample,bool p_bSuperSample, bool bHW = true); int CreateDevice (bool p_bMultiSample,bool p_bSuperSample, bool bHW = true);
int CreateDevice (void); int CreateDevice (void);
int ShutdownDevice(void); int ShutdownDevice(void);
int GetProjectionMatrix (aiMatrix4x4& p_mOut); int GetProjectionMatrix (aiMatrix4x4& p_mOut);
int LoadAsset(void); int LoadAsset(void);
int CreateAssetData(void); int CreateAssetData(void);
int DeleteAssetData(bool bNoMaterials = false); int DeleteAssetData(bool bNoMaterials = false);
int ScaleAsset(void); int ScaleAsset(void);
int DeleteAsset(void); int DeleteAsset(void);
int SetupFPSView(); int SetupFPSView();
aiVector3D GetCameraMatrix (aiMatrix4x4& p_mOut); aiVector3D GetCameraMatrix (aiMatrix4x4& p_mOut);
int CreateMaterial(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource); int CreateMaterial(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource);
void HandleMouseInputFPS( void ); void HandleMouseInputFPS( void );
void HandleMouseInputLightRotate( void ); void HandleMouseInputLightRotate( void );
void HandleMouseInputLocal( void ); void HandleMouseInputLocal( void );
void HandleKeyboardInputFPS( void ); void HandleKeyboardInputFPS( void );
void HandleMouseInputLightIntensityAndColor( void ); void HandleMouseInputLightIntensityAndColor( void );
void HandleMouseInputSkyBox( void ); void HandleMouseInputSkyBox( void );
void HandleKeyboardInputTextureView( void ); void HandleKeyboardInputTextureView( void );
void HandleMouseInputTextureView( void ); void HandleMouseInputTextureView( void );
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
@ -160,7 +161,7 @@ INT_PTR CALLBACK AboutMessageProc(HWND hwndDlg,UINT uMsg,
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
// //
// Dialog prcoedure for the help dialog // Dialog procedure for the help dialog
// //
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
INT_PTR CALLBACK HelpDialogProc(HWND hwndDlg,UINT uMsg, INT_PTR CALLBACK HelpDialogProc(HWND hwndDlg,UINT uMsg,
@ -182,7 +183,7 @@ type clamp(intype in)
{ {
// for unsigned types only ... // for unsigned types only ...
intype mask = (0x1u << (sizeof(type)*8))-1; intype mask = (0x1u << (sizeof(type)*8))-1;
return (type)std::max((intype)0,std::min(in,mask)); return (type)max((intype)0,min(in,mask));
} }