1491 lines
50 KiB
C++
1491 lines
50 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (assimp)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2022, assimp team
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the following
|
|
conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the assimp team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the assimp team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
---------------------------------------------------------------------------
|
|
*/
|
|
#include "assimp_view.h"
|
|
|
|
#include "MaterialManager.h"
|
|
#include "AssetHelper.h"
|
|
|
|
#include <assimp/cimport.h>
|
|
#include <assimp/Importer.hpp>
|
|
#include <assimp/ai_assert.h>
|
|
#include <assimp/cfileio.h>
|
|
#include <assimp/postprocess.h>
|
|
#include <assimp/scene.h>
|
|
#include <assimp/IOSystem.hpp>
|
|
#include <assimp/IOStream.hpp>
|
|
#include <assimp/LogStream.hpp>
|
|
#include <assimp/DefaultLogger.hpp>
|
|
#include <assimp/StringComparison.h>
|
|
|
|
#include <vector>
|
|
#include <algorithm>
|
|
|
|
namespace AssimpView {
|
|
|
|
using namespace Assimp;
|
|
|
|
extern std::string g_szMaterialShader;
|
|
extern HINSTANCE g_hInstance /*= NULL*/;
|
|
extern HWND g_hDlg /*= NULL*/;
|
|
extern IDirect3D9* g_piD3D /*= NULL*/;
|
|
extern IDirect3DDevice9* g_piDevice /*= NULL*/;
|
|
extern IDirect3DVertexDeclaration9* gDefaultVertexDecl /*= NULL*/;
|
|
extern double g_fFPS /*= 0.0f*/;
|
|
extern char g_szFileName[ MAX_PATH ];
|
|
extern ID3DXEffect* g_piDefaultEffect /*= NULL*/;
|
|
extern ID3DXEffect* g_piNormalsEffect /*= NULL*/;
|
|
extern ID3DXEffect* g_piPassThroughEffect /*= NULL*/;
|
|
extern ID3DXEffect* g_piPatternEffect /*= NULL*/;
|
|
extern bool g_bMousePressed /*= false*/;
|
|
extern bool g_bMousePressedR /*= false*/;
|
|
extern bool g_bMousePressedM /*= false*/;
|
|
extern bool g_bMousePressedBoth /*= false*/;
|
|
extern float g_fElpasedTime /*= 0.0f*/;
|
|
extern D3DCAPS9 g_sCaps;
|
|
extern bool g_bLoadingFinished /*= false*/;
|
|
extern HANDLE g_hThreadHandle /*= NULL*/;
|
|
extern float g_fWheelPos /*= -10.0f*/;
|
|
extern bool g_bLoadingCanceled /*= false*/;
|
|
extern IDirect3DTexture9* g_pcTexture /*= NULL*/;
|
|
|
|
extern aiMatrix4x4 g_mWorld;
|
|
extern aiMatrix4x4 g_mWorldRotate;
|
|
extern aiVector3D g_vRotateSpeed /*= aiVector3D(0.5f,0.5f,0.5f)*/;
|
|
|
|
extern aiVector3D g_avLightDirs[ 1 ] /* =
|
|
{ aiVector3D(-0.5f,0.6f,0.2f) ,
|
|
aiVector3D(-0.5f,0.5f,0.5f)} */;
|
|
|
|
|
|
extern POINT g_mousePos /*= {0,0};*/;
|
|
extern POINT g_LastmousePos /*= {0,0}*/;
|
|
extern bool g_bFPSView /*= false*/;
|
|
extern bool g_bInvert /*= false*/;
|
|
extern EClickPos g_eClick;
|
|
extern unsigned int g_iCurrentColor /*= 0*/;
|
|
|
|
// NOTE: The light intensity is separated from the color, it can
|
|
// directly be manipulated using the middle mouse button.
|
|
// When the user chooses a color from the palette the intensity
|
|
// is reset to 1.0
|
|
// index[2] is the ambient color
|
|
extern float g_fLightIntensity /*=0.0f*/;
|
|
extern D3DCOLOR g_avLightColors[ 3 ];
|
|
|
|
extern RenderOptions g_sOptions;
|
|
extern Camera g_sCamera;
|
|
extern AssetHelper *g_pcAsset /*= NULL*/;
|
|
|
|
|
|
//
|
|
// Contains the mask image for the HUD
|
|
// (used to determine the position of a click)
|
|
//
|
|
// The size of the image is identical to the size of the main
|
|
// HUD texture
|
|
//
|
|
extern unsigned char* g_szImageMask /*= NULL*/;
|
|
|
|
|
|
extern float g_fACMR /*= 3.0f*/;
|
|
extern IDirect3DQuery9* g_piQuery;
|
|
|
|
extern bool g_bPlay /*= false*/;
|
|
|
|
extern double g_dCurrent;
|
|
extern float g_smoothAngle /*= 80.f*/;
|
|
|
|
extern unsigned int ppsteps, ppstepsdefault;
|
|
extern bool nopointslines;
|
|
|
|
CMaterialManager CMaterialManager::s_cInstance;
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// D3DX callback function to fill a texture with a checkers pattern
|
|
//
|
|
// This pattern is used to mark textures which could not be loaded
|
|
//-------------------------------------------------------------------------------
|
|
VOID WINAPI FillFunc(D3DXVECTOR4* pOut,
|
|
CONST D3DXVECTOR2* pTexCoord,
|
|
CONST D3DXVECTOR2* pTexelSize,
|
|
LPVOID pData)
|
|
{
|
|
UNREFERENCED_PARAMETER(pData);
|
|
UNREFERENCED_PARAMETER(pTexelSize);
|
|
|
|
// generate a nice checker pattern (yellow/black)
|
|
// size of a square: 32 * 32 px
|
|
unsigned int iX = (unsigned int)(pTexCoord->x * 256.0f);
|
|
unsigned int iY = (unsigned int)(pTexCoord->y * 256.0f);
|
|
|
|
bool bBlack = false;
|
|
if ((iX / 32) % 2 == 0)
|
|
{
|
|
if ((iY / 32) % 2 == 0)bBlack = true;
|
|
}
|
|
else
|
|
{
|
|
if ((iY / 32) % 2 != 0)bBlack = true;
|
|
}
|
|
pOut->w = 1.0f;
|
|
if (bBlack)
|
|
{
|
|
pOut->x = pOut->y = pOut->z = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
pOut->x = pOut->y = 1.0f;
|
|
pOut->z = 0.0f;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int CMaterialManager::UpdateSpecularMaterials() {
|
|
if (g_pcAsset && g_pcAsset->pcScene) {
|
|
for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i) {
|
|
if (aiShadingMode_Phong == g_pcAsset->apcMeshes[i]->eShadingMode) {
|
|
this->DeleteMaterial(g_pcAsset->apcMeshes[i]);
|
|
this->CreateMaterial(g_pcAsset->apcMeshes[i],g_pcAsset->pcScene->mMeshes[i]);
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int CMaterialManager::SetDefaultTexture(IDirect3DTexture9** p_ppiOut) {
|
|
if (sDefaultTexture) {
|
|
sDefaultTexture->AddRef();
|
|
*p_ppiOut = sDefaultTexture;
|
|
return 1;
|
|
}
|
|
|
|
if(FAILED(g_piDevice->CreateTexture(
|
|
256,
|
|
256,
|
|
0,
|
|
0,
|
|
D3DFMT_A8R8G8B8,
|
|
D3DPOOL_MANAGED,
|
|
p_ppiOut,
|
|
nullptr)))
|
|
{
|
|
CLogDisplay::Instance().AddEntry("[ERROR] Unable to create default texture",
|
|
D3DCOLOR_ARGB(0xFF,0xFF,0,0));
|
|
|
|
*p_ppiOut = nullptr;
|
|
return 0;
|
|
}
|
|
D3DXFillTexture(*p_ppiOut,&FillFunc,nullptr);
|
|
sDefaultTexture = *p_ppiOut;
|
|
sDefaultTexture->AddRef();
|
|
|
|
// {9785DA94-1D96-426b-B3CB-BADC36347F5E}
|
|
static const GUID guidPrivateData =
|
|
{ 0x9785da94, 0x1d96, 0x426b,
|
|
{ 0xb3, 0xcb, 0xba, 0xdc, 0x36, 0x34, 0x7f, 0x5e } };
|
|
|
|
uint32_t iData = 0xFFFFFFFF;
|
|
(*p_ppiOut)->SetPrivateData(guidPrivateData,&iData,4,0);
|
|
return 1;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
bool CMaterialManager::TryLongerPath(char* szTemp,aiString* p_szString)
|
|
{
|
|
char szTempB[MAX_PATH];
|
|
strcpy(szTempB,szTemp);
|
|
|
|
// go to the beginning of the file name
|
|
char* szFile = strrchr(szTempB,'\\');
|
|
if (!szFile)szFile = strrchr(szTempB,'/');
|
|
|
|
char* szFile2 = szTemp + (szFile - szTempB)+1;
|
|
szFile++;
|
|
char* szExt = strrchr(szFile,'.');
|
|
if (!szExt)return false;
|
|
szExt++;
|
|
*szFile = 0;
|
|
|
|
strcat(szTempB,"*.*");
|
|
const unsigned int iSize = (const unsigned int) ( szExt - 1 - szFile );
|
|
|
|
HANDLE h;
|
|
WIN32_FIND_DATA info;
|
|
|
|
// build a list of files
|
|
h = FindFirstFile(szTempB, &info);
|
|
if (h != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
if (!(strcmp(info.cFileName, ".") == 0 || strcmp(info.cFileName, "..") == 0))
|
|
{
|
|
char* szExtFound = strrchr(info.cFileName, '.');
|
|
if (szExtFound)
|
|
{
|
|
++szExtFound;
|
|
if (0 == ASSIMP_stricmp(szExtFound,szExt))
|
|
{
|
|
const unsigned int iSizeFound = (const unsigned int) (
|
|
szExtFound - 1 - info.cFileName);
|
|
|
|
for (unsigned int i = 0; i < iSizeFound;++i)
|
|
info.cFileName[i] = (CHAR)tolower((unsigned char)info.cFileName[i]);
|
|
|
|
if (0 == memcmp(info.cFileName,szFile2, std::min(iSizeFound,iSize)))
|
|
{
|
|
// we have it. Build the full path ...
|
|
char* sz = strrchr(szTempB,'*');
|
|
*(sz-2) = 0x0;
|
|
|
|
strcat(szTempB,info.cFileName);
|
|
|
|
// copy the result string back to the aiString
|
|
const size_t iLen = strlen(szTempB);
|
|
size_t iLen2 = iLen+1;
|
|
iLen2 = iLen2 > MAXLEN ? MAXLEN : iLen2;
|
|
memcpy(p_szString->data,szTempB,iLen2);
|
|
p_szString->length = static_cast<ai_uint32>(iLen);
|
|
return true;
|
|
}
|
|
}
|
|
// check whether the 8.3 DOS name is matching
|
|
if (0 == ASSIMP_stricmp(info.cAlternateFileName,p_szString->data))
|
|
{
|
|
strcat(szTempB,info.cAlternateFileName);
|
|
|
|
// copy the result string back to the aiString
|
|
const size_t iLen = strlen(szTempB);
|
|
size_t iLen2 = iLen+1;
|
|
iLen2 = iLen2 > MAXLEN ? MAXLEN : iLen2;
|
|
memcpy(p_szString->data,szTempB,iLen2);
|
|
p_szString->length = static_cast<ai_uint32>(iLen);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
while (FindNextFile(h, &info));
|
|
|
|
FindClose(h);
|
|
}
|
|
return false;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
int CMaterialManager::FindValidPath(aiString* p_szString)
|
|
{
|
|
ai_assert(nullptr != p_szString);
|
|
aiString pcpy = *p_szString;
|
|
if ('*' == p_szString->data[0]) {
|
|
// '*' as first character indicates an embedded file
|
|
return 5;
|
|
}
|
|
|
|
// first check whether we can directly load the file
|
|
FILE* pFile = fopen(p_szString->data,"rb");
|
|
if (pFile) {
|
|
fclose(pFile);
|
|
}
|
|
else {
|
|
// check whether we can use the directory of the asset as relative base
|
|
char szTemp[MAX_PATH*2], tmp2[MAX_PATH*2];
|
|
strcpy(szTemp, g_szFileName);
|
|
strcpy(tmp2,szTemp);
|
|
|
|
char* szData = p_szString->data;
|
|
if (*szData == '\\' || *szData == '/')++szData;
|
|
|
|
char* szEnd = strrchr(szTemp,'\\');
|
|
if (!szEnd)
|
|
{
|
|
szEnd = strrchr(szTemp,'/');
|
|
if (!szEnd)szEnd = szTemp;
|
|
}
|
|
szEnd++;
|
|
*szEnd = 0;
|
|
strcat(szEnd,szData);
|
|
|
|
|
|
pFile = fopen(szTemp,"rb");
|
|
if (!pFile)
|
|
{
|
|
// convert the string to lower case
|
|
for (unsigned int i = 0;;++i)
|
|
{
|
|
if ('\0' == szTemp[i])break;
|
|
szTemp[i] = (char)tolower((unsigned char)szTemp[i]);
|
|
}
|
|
|
|
if(TryLongerPath(szTemp,p_szString))return 1;
|
|
*szEnd = 0;
|
|
|
|
// search common sub directories
|
|
strcat(szEnd,"tex\\");
|
|
strcat(szEnd,szData);
|
|
|
|
pFile = fopen(szTemp,"rb");
|
|
if (!pFile)
|
|
{
|
|
if(TryLongerPath(szTemp,p_szString))return 1;
|
|
|
|
*szEnd = 0;
|
|
|
|
strcat(szEnd,"textures\\");
|
|
strcat(szEnd,szData);
|
|
|
|
pFile = fopen(szTemp,"rb");
|
|
if (!pFile)
|
|
{
|
|
if(TryLongerPath(szTemp, p_szString))return 1;
|
|
}
|
|
|
|
// patch by mark sibly to look for textures files in the asset's base directory.
|
|
const char *path=pcpy.data;
|
|
const char *p=strrchr( path,'/' );
|
|
if( !p ) p=strrchr( path,'\\' );
|
|
if( p ){
|
|
char *q=strrchr( tmp2,'/' );
|
|
if( !q ) q=strrchr( tmp2,'\\' );
|
|
if( q ){
|
|
strcpy( q+1,p+1 );
|
|
if((pFile=fopen( tmp2,"r" )) != nullptr){
|
|
fclose( pFile );
|
|
strcpy(p_szString->data,tmp2);
|
|
p_szString->length = static_cast<ai_uint32>(strlen(tmp2));
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
fclose(pFile);
|
|
|
|
// copy the result string back to the aiStr
|
|
const size_t len = strlen(szTemp);
|
|
size_t len2 = len+1;
|
|
len2 = len2 > MAXLEN ? MAXLEN : len2;
|
|
memcpy(p_szString->data, szTemp, len2);
|
|
p_szString->length = static_cast<ai_uint32>(len);
|
|
}
|
|
return 1;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath)
|
|
{
|
|
ai_assert(nullptr != p_ppiOut);
|
|
ai_assert(nullptr != szPath);
|
|
|
|
*p_ppiOut = nullptr;
|
|
|
|
const std::string s = szPath->data;
|
|
TextureCache::iterator ff;
|
|
if ((ff = sCachedTextures.find(s)) != sCachedTextures.end()) {
|
|
*p_ppiOut = (*ff).second;
|
|
(*p_ppiOut)->AddRef();
|
|
return 1;
|
|
}
|
|
|
|
// first get a valid path to the texture
|
|
if( 5 == FindValidPath(szPath))
|
|
{
|
|
// embedded file. Find its index
|
|
unsigned int iIndex = atoi(szPath->data+1);
|
|
if (iIndex < g_pcAsset->pcScene->mNumTextures)
|
|
{
|
|
if (0 == g_pcAsset->pcScene->mTextures[iIndex]->mHeight)
|
|
{
|
|
// it is an embedded file ... don't need the file format hint,
|
|
// simply let D3DX load the file
|
|
D3DXIMAGE_INFO info;
|
|
if (FAILED(D3DXCreateTextureFromFileInMemoryEx(g_piDevice,
|
|
g_pcAsset->pcScene->mTextures[iIndex]->pcData,
|
|
g_pcAsset->pcScene->mTextures[iIndex]->mWidth,
|
|
D3DX_DEFAULT,
|
|
D3DX_DEFAULT,
|
|
1,
|
|
D3DUSAGE_AUTOGENMIPMAP,
|
|
D3DFMT_UNKNOWN,
|
|
D3DPOOL_MANAGED,
|
|
D3DX_DEFAULT,
|
|
D3DX_DEFAULT,
|
|
0,
|
|
&info,
|
|
nullptr,
|
|
p_ppiOut)))
|
|
{
|
|
std::string sz = "[ERROR] Unable to load embedded texture (#1): ";
|
|
sz.append(szPath->data);
|
|
CLogDisplay::Instance().AddEntry(sz,D3DCOLOR_ARGB(0xFF,0xFF,0x0,0x0));
|
|
|
|
this->SetDefaultTexture(p_ppiOut);
|
|
return 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// fill a new texture ...
|
|
if(FAILED(g_piDevice->CreateTexture(
|
|
g_pcAsset->pcScene->mTextures[iIndex]->mWidth,
|
|
g_pcAsset->pcScene->mTextures[iIndex]->mHeight,
|
|
0,D3DUSAGE_AUTOGENMIPMAP,D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,p_ppiOut,nullptr)))
|
|
{
|
|
std::string sz = "[ERROR] Unable to load embedded texture (#2): ";
|
|
sz.append(szPath->data);
|
|
CLogDisplay::Instance().AddEntry(sz,D3DCOLOR_ARGB(0xFF,0xFF,0x0,0x0));
|
|
|
|
this->SetDefaultTexture(p_ppiOut);
|
|
return 1;
|
|
}
|
|
|
|
// now copy the data to it ... (assume non pow2 to be supported)
|
|
D3DLOCKED_RECT sLock;
|
|
(*p_ppiOut)->LockRect(0,&sLock,nullptr,0);
|
|
|
|
const aiTexel* pcData = g_pcAsset->pcScene->mTextures[iIndex]->pcData;
|
|
|
|
for (unsigned int y = 0; y < g_pcAsset->pcScene->mTextures[iIndex]->mHeight;++y)
|
|
{
|
|
memcpy(sLock.pBits,pcData,g_pcAsset->pcScene->mTextures[iIndex]->
|
|
mWidth *sizeof(aiTexel));
|
|
sLock.pBits = (char*)sLock.pBits + sLock.Pitch;
|
|
pcData += g_pcAsset->pcScene->mTextures[iIndex]->mWidth;
|
|
}
|
|
(*p_ppiOut)->UnlockRect(0);
|
|
(*p_ppiOut)->GenerateMipSubLevels();
|
|
}
|
|
sCachedTextures[s] = *p_ppiOut;
|
|
(*p_ppiOut)->AddRef();
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
std::string sz = "[ERROR] Invalid index for embedded texture: ";
|
|
sz.append(szPath->data);
|
|
CLogDisplay::Instance().AddEntry(sz,D3DCOLOR_ARGB(0xFF,0xFF,0x0,0x0));
|
|
|
|
SetDefaultTexture(p_ppiOut);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// then call D3DX to load the texture
|
|
if (FAILED(D3DXCreateTextureFromFileEx(
|
|
g_piDevice,
|
|
szPath->data,
|
|
D3DX_DEFAULT,
|
|
D3DX_DEFAULT,
|
|
0,
|
|
0,
|
|
D3DFMT_A8R8G8B8,
|
|
D3DPOOL_MANAGED,
|
|
D3DX_DEFAULT,
|
|
D3DX_DEFAULT,
|
|
0,
|
|
nullptr,
|
|
nullptr,
|
|
p_ppiOut)))
|
|
{
|
|
// error ... use the default texture instead
|
|
std::string sz = "[ERROR] Unable to load texture: ";
|
|
sz.append(szPath->data);
|
|
CLogDisplay::Instance().AddEntry(sz,D3DCOLOR_ARGB(0xFF,0xFF,0x0,0x0));
|
|
|
|
this->SetDefaultTexture(p_ppiOut);
|
|
}
|
|
sCachedTextures[s] = *p_ppiOut;
|
|
(*p_ppiOut)->AddRef();
|
|
|
|
return 1;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
void CMaterialManager::DeleteMaterial(AssetHelper::MeshHelper* pcIn)
|
|
{
|
|
if (!pcIn || !pcIn->piEffect)return;
|
|
pcIn->piEffect->Release();
|
|
|
|
// release all textures associated with the material
|
|
if (pcIn->piDiffuseTexture)
|
|
{
|
|
pcIn->piDiffuseTexture->Release();
|
|
pcIn->piDiffuseTexture = nullptr;
|
|
}
|
|
if (pcIn->piSpecularTexture)
|
|
{
|
|
pcIn->piSpecularTexture->Release();
|
|
pcIn->piSpecularTexture = nullptr;
|
|
}
|
|
if (pcIn->piEmissiveTexture)
|
|
{
|
|
pcIn->piEmissiveTexture->Release();
|
|
pcIn->piEmissiveTexture = nullptr;
|
|
}
|
|
if (pcIn->piAmbientTexture)
|
|
{
|
|
pcIn->piAmbientTexture->Release();
|
|
pcIn->piAmbientTexture = nullptr;
|
|
}
|
|
if (pcIn->piOpacityTexture)
|
|
{
|
|
pcIn->piOpacityTexture->Release();
|
|
pcIn->piOpacityTexture = nullptr;
|
|
}
|
|
if (pcIn->piNormalTexture)
|
|
{
|
|
pcIn->piNormalTexture->Release();
|
|
pcIn->piNormalTexture = nullptr;
|
|
}
|
|
if (pcIn->piShininessTexture)
|
|
{
|
|
pcIn->piShininessTexture->Release();
|
|
pcIn->piShininessTexture = nullptr;
|
|
}
|
|
if (pcIn->piLightmapTexture)
|
|
{
|
|
pcIn->piLightmapTexture->Release();
|
|
pcIn->piLightmapTexture = nullptr;
|
|
}
|
|
pcIn->piEffect = nullptr;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
void CMaterialManager::HMtoNMIfNecessary(
|
|
IDirect3DTexture9* piTexture,
|
|
IDirect3DTexture9** piTextureOut,
|
|
bool bWasOriginallyHM)
|
|
{
|
|
ai_assert(nullptr != piTexture);
|
|
ai_assert(nullptr != piTextureOut);
|
|
|
|
bool bMustConvert = false;
|
|
uintptr_t iElement = 3;
|
|
|
|
*piTextureOut = piTexture;
|
|
|
|
// Lock the input texture and try to determine its type.
|
|
// Criteria:
|
|
// - If r,g,b channel are identical it MUST be a height map
|
|
// - If one of the rgb channels is used and the others are empty it
|
|
// must be a height map, too.
|
|
// - If the average color of the whole image is something inside the
|
|
// purple range we can be sure it is a normal map
|
|
//
|
|
// - Otherwise we assume it is a normal map
|
|
// To increase performance we take not every pixel
|
|
|
|
D3DLOCKED_RECT sRect;
|
|
D3DSURFACE_DESC sDesc;
|
|
piTexture->GetLevelDesc(0,&sDesc);
|
|
if (FAILED(piTexture->LockRect(0,&sRect,nullptr,D3DLOCK_READONLY)))
|
|
{
|
|
return;
|
|
}
|
|
const int iPitchDiff = (int)sRect.Pitch - (int)(sDesc.Width * 4);
|
|
|
|
struct SColor
|
|
{
|
|
union
|
|
{
|
|
struct {unsigned char b,g,r,a;} data;
|
|
char _array[4];
|
|
};
|
|
};
|
|
const SColor* pcData = (const SColor*)sRect.pBits;
|
|
|
|
union
|
|
{
|
|
const SColor* pcPointer;
|
|
const unsigned char* pcCharPointer;
|
|
};
|
|
pcPointer = pcData;
|
|
|
|
// 1. If r,g,b channel are identical it MUST be a height map
|
|
bool bIsEqual = true;
|
|
for (unsigned int y = 0; y < sDesc.Height;++y)
|
|
{
|
|
for (unsigned int x = 0; x < sDesc.Width;++x)
|
|
{
|
|
if (pcPointer->data.b != pcPointer->data.r || pcPointer->data.b != pcPointer->data.g)
|
|
{
|
|
bIsEqual = false;
|
|
break;
|
|
}
|
|
pcPointer++;
|
|
}
|
|
pcCharPointer += iPitchDiff;
|
|
}
|
|
if (bIsEqual)bMustConvert = true;
|
|
else
|
|
{
|
|
// 2. If one of the rgb channels is used and the others are empty it
|
|
// must be a height map, too.
|
|
pcPointer = pcData;
|
|
while (*pcCharPointer == 0)pcCharPointer++;
|
|
|
|
iElement = (uintptr_t)(pcCharPointer - (unsigned char*)pcData) % 4;
|
|
unsigned int aiIndex[3] = {0,1,2};
|
|
if (3 != iElement)aiIndex[iElement] = 3;
|
|
|
|
pcPointer = pcData;
|
|
|
|
bIsEqual = true;
|
|
if (3 != iElement)
|
|
{
|
|
for (unsigned int y = 0; y < sDesc.Height;++y)
|
|
{
|
|
for (unsigned int x = 0; x < sDesc.Width;++x)
|
|
{
|
|
for (unsigned int ii = 0; ii < 3;++ii)
|
|
{
|
|
// don't take the alpha channel into account.
|
|
// if the texture was stored n RGB888 format D3DX has
|
|
// converted it to ARGB8888 format with a fixed alpha channel
|
|
if (aiIndex[ii] != 3 && pcPointer->_array[aiIndex[ii]] != 0)
|
|
{
|
|
bIsEqual = false;
|
|
break;
|
|
}
|
|
}
|
|
pcPointer++;
|
|
}
|
|
pcCharPointer += iPitchDiff;
|
|
}
|
|
if (bIsEqual)bMustConvert = true;
|
|
else
|
|
{
|
|
// If the average color of the whole image is something inside the
|
|
// purple range we can be sure it is a normal map
|
|
|
|
// (calculate the average color line per line to prevent overflows!)
|
|
pcPointer = pcData;
|
|
aiColor3D clrColor;
|
|
for (unsigned int y = 0; y < sDesc.Height;++y)
|
|
{
|
|
aiColor3D clrColorLine;
|
|
for (unsigned int x = 0; x < sDesc.Width;++x)
|
|
{
|
|
clrColorLine.r += pcPointer->data.r;
|
|
clrColorLine.g += pcPointer->data.g;
|
|
clrColorLine.b += pcPointer->data.b;
|
|
pcPointer++;
|
|
}
|
|
clrColor.r += clrColorLine.r /= (float)sDesc.Width;
|
|
clrColor.g += clrColorLine.g /= (float)sDesc.Width;
|
|
clrColor.b += clrColorLine.b /= (float)sDesc.Width;
|
|
pcCharPointer += iPitchDiff;
|
|
}
|
|
clrColor.r /= (float)sDesc.Height;
|
|
clrColor.g /= (float)sDesc.Height;
|
|
clrColor.b /= (float)sDesc.Height;
|
|
|
|
if (!(clrColor.b > 215 &&
|
|
clrColor.r > 100 && clrColor.r < 140 &&
|
|
clrColor.g > 100 && clrColor.g < 140))
|
|
{
|
|
// Unable to detect. Believe the original value obtained from the loader
|
|
if (bWasOriginallyHM)
|
|
{
|
|
bMustConvert = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
piTexture->UnlockRect(0);
|
|
|
|
// if the input data is assumed to be a height map we'll
|
|
// need to convert it NOW
|
|
if (bMustConvert)
|
|
{
|
|
D3DSURFACE_DESC sDesc2;
|
|
piTexture->GetLevelDesc(0, &sDesc2);
|
|
|
|
IDirect3DTexture9* piTempTexture;
|
|
if(FAILED(g_piDevice->CreateTexture(
|
|
sDesc2.Width,
|
|
sDesc2.Height,
|
|
piTexture->GetLevelCount(),
|
|
sDesc2.Usage,
|
|
sDesc2.Format,
|
|
sDesc2.Pool, &piTempTexture, nullptr)))
|
|
{
|
|
CLogDisplay::Instance().AddEntry(
|
|
"[ERROR] Unable to create normal map texture",
|
|
D3DCOLOR_ARGB(0xFF,0xFF,0x0,0x0));
|
|
return;
|
|
}
|
|
|
|
DWORD dwFlags;
|
|
if (3 == iElement)dwFlags = D3DX_CHANNEL_LUMINANCE;
|
|
else if (2 == iElement)dwFlags = D3DX_CHANNEL_RED;
|
|
else if (1 == iElement)dwFlags = D3DX_CHANNEL_GREEN;
|
|
else /*if (0 == iElement)*/dwFlags = D3DX_CHANNEL_BLUE;
|
|
|
|
if(FAILED(D3DXComputeNormalMap(piTempTexture,
|
|
piTexture,nullptr,0,dwFlags,1.0f)))
|
|
{
|
|
CLogDisplay::Instance().AddEntry(
|
|
"[ERROR] Unable to compute normal map from height map",
|
|
D3DCOLOR_ARGB(0xFF,0xFF,0x0,0x0));
|
|
|
|
piTempTexture->Release();
|
|
return;
|
|
}
|
|
*piTextureOut = piTempTexture;
|
|
piTexture->Release();
|
|
}
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
bool CMaterialManager::HasAlphaPixels(IDirect3DTexture9* piTexture)
|
|
{
|
|
ai_assert(nullptr != piTexture);
|
|
|
|
D3DLOCKED_RECT sRect;
|
|
D3DSURFACE_DESC sDesc;
|
|
piTexture->GetLevelDesc(0,&sDesc);
|
|
if (FAILED(piTexture->LockRect(0,&sRect,nullptr,D3DLOCK_READONLY)))
|
|
{
|
|
return false;
|
|
}
|
|
const int iPitchDiff = (int)sRect.Pitch - (int)(sDesc.Width * 4);
|
|
|
|
struct SColor
|
|
{
|
|
unsigned char b,g,r,a;;
|
|
};
|
|
const SColor* pcData = (const SColor*)sRect.pBits;
|
|
|
|
union
|
|
{
|
|
const SColor* pcPointer;
|
|
const unsigned char* pcCharPointer;
|
|
};
|
|
pcPointer = pcData;
|
|
for (unsigned int y = 0; y < sDesc.Height;++y)
|
|
{
|
|
for (unsigned int x = 0; x < sDesc.Width;++x)
|
|
{
|
|
if (pcPointer->a != 0xFF)
|
|
{
|
|
piTexture->UnlockRect(0);
|
|
return true;
|
|
}
|
|
pcPointer++;
|
|
}
|
|
pcCharPointer += iPitchDiff;
|
|
}
|
|
piTexture->UnlockRect(0);
|
|
return false;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
int CMaterialManager::CreateMaterial(
|
|
AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource)
|
|
{
|
|
ai_assert(nullptr != pcMesh);
|
|
ai_assert(nullptr != pcSource);
|
|
|
|
ID3DXBuffer* piBuffer;
|
|
|
|
D3DXMACRO sMacro[64];
|
|
|
|
// extract all properties from the ASSIMP material structure
|
|
const aiMaterial* pcMat = g_pcAsset->pcScene->mMaterials[pcSource->mMaterialIndex];
|
|
|
|
//
|
|
// DIFFUSE COLOR --------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_DIFFUSE,
|
|
(aiColor4D*)&pcMesh->vDiffuseColor))
|
|
{
|
|
pcMesh->vDiffuseColor.x = 1.0f;
|
|
pcMesh->vDiffuseColor.y = 1.0f;
|
|
pcMesh->vDiffuseColor.z = 1.0f;
|
|
pcMesh->vDiffuseColor.w = 1.0f;
|
|
}
|
|
//
|
|
// SPECULAR COLOR --------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_SPECULAR,
|
|
(aiColor4D*)&pcMesh->vSpecularColor))
|
|
{
|
|
pcMesh->vSpecularColor.x = 1.0f;
|
|
pcMesh->vSpecularColor.y = 1.0f;
|
|
pcMesh->vSpecularColor.z = 1.0f;
|
|
pcMesh->vSpecularColor.w = 1.0f;
|
|
}
|
|
//
|
|
// AMBIENT COLOR --------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_AMBIENT,
|
|
(aiColor4D*)&pcMesh->vAmbientColor))
|
|
{
|
|
pcMesh->vAmbientColor.x = 0.0f;
|
|
pcMesh->vAmbientColor.y = 0.0f;
|
|
pcMesh->vAmbientColor.z = 0.0f;
|
|
pcMesh->vAmbientColor.w = 1.0f;
|
|
}
|
|
//
|
|
// EMISSIVE COLOR -------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS != aiGetMaterialColor(pcMat,AI_MATKEY_COLOR_EMISSIVE,
|
|
(aiColor4D*)&pcMesh->vEmissiveColor))
|
|
{
|
|
pcMesh->vEmissiveColor.x = 0.0f;
|
|
pcMesh->vEmissiveColor.y = 0.0f;
|
|
pcMesh->vEmissiveColor.z = 0.0f;
|
|
pcMesh->vEmissiveColor.w = 1.0f;
|
|
}
|
|
|
|
//
|
|
// Opacity --------------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS != aiGetMaterialFloat(pcMat,AI_MATKEY_OPACITY,&pcMesh->fOpacity))
|
|
{
|
|
pcMesh->fOpacity = 1.0f;
|
|
}
|
|
|
|
//
|
|
// Shading Model --------------------------------------------------
|
|
//
|
|
bool bDefault = false;
|
|
if(AI_SUCCESS != aiGetMaterialInteger(pcMat,AI_MATKEY_SHADING_MODEL,(int*)&pcMesh->eShadingMode ))
|
|
{
|
|
bDefault = true;
|
|
pcMesh->eShadingMode = aiShadingMode_Gouraud;
|
|
}
|
|
|
|
|
|
//
|
|
// Shininess ------------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS != aiGetMaterialFloat(pcMat,AI_MATKEY_SHININESS,&pcMesh->fShininess))
|
|
{
|
|
// assume 15 as default shininess
|
|
pcMesh->fShininess = 15.0f;
|
|
}
|
|
else if (bDefault)pcMesh->eShadingMode = aiShadingMode_Phong;
|
|
|
|
|
|
//
|
|
// Shininess strength ------------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS != aiGetMaterialFloat(pcMat,AI_MATKEY_SHININESS_STRENGTH,&pcMesh->fSpecularStrength))
|
|
{
|
|
// assume 1.0 as default shininess strength
|
|
pcMesh->fSpecularStrength = 1.0f;
|
|
}
|
|
|
|
aiString szPath;
|
|
|
|
aiTextureMapMode mapU(aiTextureMapMode_Wrap),mapV(aiTextureMapMode_Wrap);
|
|
|
|
bool bib =false;
|
|
if (pcSource->mTextureCoords[0])
|
|
{
|
|
|
|
//
|
|
// DIFFUSE TEXTURE ------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_DIFFUSE(0),&szPath))
|
|
{
|
|
LoadTexture(&pcMesh->piDiffuseTexture,&szPath);
|
|
|
|
aiGetMaterialInteger(pcMat,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0),(int*)&mapU);
|
|
aiGetMaterialInteger(pcMat,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0),(int*)&mapV);
|
|
}
|
|
|
|
//
|
|
// SPECULAR TEXTURE ------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_SPECULAR(0),&szPath))
|
|
{
|
|
LoadTexture(&pcMesh->piSpecularTexture,&szPath);
|
|
}
|
|
|
|
//
|
|
// OPACITY TEXTURE ------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_OPACITY(0),&szPath))
|
|
{
|
|
LoadTexture(&pcMesh->piOpacityTexture,&szPath);
|
|
}
|
|
else
|
|
{
|
|
int flags = 0;
|
|
aiGetMaterialInteger(pcMat,AI_MATKEY_TEXFLAGS_DIFFUSE(0),&flags);
|
|
|
|
// try to find out whether the diffuse texture has any
|
|
// non-opaque pixels. If we find a few, use it as opacity texture
|
|
if (pcMesh->piDiffuseTexture && !(flags & aiTextureFlags_IgnoreAlpha) && HasAlphaPixels(pcMesh->piDiffuseTexture))
|
|
{
|
|
int iVal;
|
|
|
|
// NOTE: This special value is set by the tree view if the user
|
|
// manually removes the alpha texture from the view ...
|
|
if (AI_SUCCESS != aiGetMaterialInteger(pcMat,"no_a_from_d",0,0,&iVal))
|
|
{
|
|
pcMesh->piOpacityTexture = pcMesh->piDiffuseTexture;
|
|
pcMesh->piOpacityTexture->AddRef();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// AMBIENT TEXTURE ------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_AMBIENT(0),&szPath))
|
|
{
|
|
LoadTexture(&pcMesh->piAmbientTexture,&szPath);
|
|
}
|
|
|
|
//
|
|
// EMISSIVE TEXTURE ------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_EMISSIVE(0),&szPath))
|
|
{
|
|
LoadTexture(&pcMesh->piEmissiveTexture,&szPath);
|
|
}
|
|
|
|
//
|
|
// Shininess TEXTURE ------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_SHININESS(0),&szPath))
|
|
{
|
|
LoadTexture(&pcMesh->piShininessTexture,&szPath);
|
|
}
|
|
|
|
//
|
|
// Lightmap TEXTURE ------------------------------------------------
|
|
//
|
|
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_LIGHTMAP(0),&szPath))
|
|
{
|
|
LoadTexture(&pcMesh->piLightmapTexture,&szPath);
|
|
}
|
|
|
|
|
|
//
|
|
// NORMAL/HEIGHT MAP ------------------------------------------------
|
|
//
|
|
bool bHM = false;
|
|
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_NORMALS(0),&szPath))
|
|
{
|
|
LoadTexture(&pcMesh->piNormalTexture,&szPath);
|
|
}
|
|
else
|
|
{
|
|
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_TEXTURE_HEIGHT(0),&szPath))
|
|
{
|
|
LoadTexture(&pcMesh->piNormalTexture,&szPath);
|
|
}
|
|
else bib = true;
|
|
bHM = true;
|
|
}
|
|
|
|
// normal/height maps are sometimes mixed up. Try to detect the type
|
|
// of the texture automatically
|
|
if (pcMesh->piNormalTexture)
|
|
{
|
|
HMtoNMIfNecessary(pcMesh->piNormalTexture, &pcMesh->piNormalTexture,bHM);
|
|
}
|
|
}
|
|
|
|
// check whether a global background texture is contained
|
|
// in this material. Some loaders set this value ...
|
|
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_GLOBAL_BACKGROUND_IMAGE,&szPath))
|
|
{
|
|
CBackgroundPainter::Instance().SetTextureBG(szPath.data);
|
|
}
|
|
|
|
// BUGFIX: If the shininess is 0.0f disable phong lighting
|
|
// This is a workaround for some meshes in the DX SDK (e.g. tiny.x)
|
|
// FIX: Added this check to the x-loader, but the line remains to
|
|
// catch other loader doing the same ...
|
|
if (0.0f == pcMesh->fShininess){
|
|
pcMesh->eShadingMode = aiShadingMode_Gouraud;
|
|
}
|
|
|
|
int two_sided = 0;
|
|
aiGetMaterialInteger(pcMat,AI_MATKEY_TWOSIDED,&two_sided);
|
|
pcMesh->twosided = (two_sided != 0);
|
|
|
|
// check whether we have already a material using the same
|
|
// shader. This will decrease loading time rapidly ...
|
|
for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i)
|
|
{
|
|
if (g_pcAsset->pcScene->mMeshes[i] == pcSource)
|
|
{
|
|
break;
|
|
}
|
|
AssetHelper::MeshHelper* pc = g_pcAsset->apcMeshes[i];
|
|
|
|
if ((pcMesh->piDiffuseTexture != nullptr ? true : false) !=
|
|
(pc->piDiffuseTexture != nullptr ? true : false))
|
|
continue;
|
|
if ((pcMesh->piSpecularTexture != nullptr ? true : false) !=
|
|
(pc->piSpecularTexture != nullptr ? true : false))
|
|
continue;
|
|
if ((pcMesh->piAmbientTexture != nullptr ? true : false) !=
|
|
(pc->piAmbientTexture != nullptr ? true : false))
|
|
continue;
|
|
if ((pcMesh->piEmissiveTexture != nullptr ? true : false) !=
|
|
(pc->piEmissiveTexture != nullptr ? true : false))
|
|
continue;
|
|
if ((pcMesh->piNormalTexture != nullptr ? true : false) !=
|
|
(pc->piNormalTexture != nullptr ? true : false))
|
|
continue;
|
|
if ((pcMesh->piOpacityTexture != nullptr ? true : false) !=
|
|
(pc->piOpacityTexture != nullptr ? true : false))
|
|
continue;
|
|
if ((pcMesh->piShininessTexture != nullptr ? true : false) !=
|
|
(pc->piShininessTexture != nullptr ? true : false))
|
|
continue;
|
|
if ((pcMesh->piLightmapTexture != nullptr ? true : false) !=
|
|
(pc->piLightmapTexture != nullptr ? true : false))
|
|
continue;
|
|
if ((pcMesh->eShadingMode != aiShadingMode_Gouraud ? true : false) !=
|
|
(pc->eShadingMode != aiShadingMode_Gouraud ? true : false))
|
|
continue;
|
|
|
|
if ((pcMesh->fOpacity != 1.0f ? true : false) != (pc->fOpacity != 1.0f ? true : false))
|
|
continue;
|
|
|
|
if (pcSource->HasBones() != g_pcAsset->pcScene->mMeshes[i]->HasBones())
|
|
continue;
|
|
|
|
// we can reuse this material
|
|
if (pc->piEffect)
|
|
{
|
|
pcMesh->piEffect = pc->piEffect;
|
|
pc->bSharedFX = pcMesh->bSharedFX = true;
|
|
pcMesh->piEffect->AddRef();
|
|
return 2;
|
|
}
|
|
}
|
|
m_iShaderCount++;
|
|
|
|
// build macros for the HLSL compiler
|
|
unsigned int iCurrent = 0;
|
|
if (pcMesh->piDiffuseTexture)
|
|
{
|
|
sMacro[iCurrent].Name = "AV_DIFFUSE_TEXTURE";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
|
|
if (mapU == aiTextureMapMode_Wrap)
|
|
sMacro[iCurrent].Name = "AV_WRAPU";
|
|
else if (mapU == aiTextureMapMode_Mirror)
|
|
sMacro[iCurrent].Name = "AV_MIRRORU";
|
|
else // if (mapU == aiTextureMapMode_Clamp)
|
|
sMacro[iCurrent].Name = "AV_CLAMPU";
|
|
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
|
|
|
|
if (mapV == aiTextureMapMode_Wrap)
|
|
sMacro[iCurrent].Name = "AV_WRAPV";
|
|
else if (mapV == aiTextureMapMode_Mirror)
|
|
sMacro[iCurrent].Name = "AV_MIRRORV";
|
|
else // if (mapV == aiTextureMapMode_Clamp)
|
|
sMacro[iCurrent].Name = "AV_CLAMPV";
|
|
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
}
|
|
if (pcMesh->piSpecularTexture)
|
|
{
|
|
sMacro[iCurrent].Name = "AV_SPECULAR_TEXTURE";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
}
|
|
if (pcMesh->piAmbientTexture)
|
|
{
|
|
sMacro[iCurrent].Name = "AV_AMBIENT_TEXTURE";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
}
|
|
if (pcMesh->piEmissiveTexture)
|
|
{
|
|
sMacro[iCurrent].Name = "AV_EMISSIVE_TEXTURE";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
}
|
|
char buff[32];
|
|
if (pcMesh->piLightmapTexture)
|
|
{
|
|
sMacro[iCurrent].Name = "AV_LIGHTMAP_TEXTURE";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
|
|
int idx;
|
|
if(AI_SUCCESS == aiGetMaterialInteger(pcMat,AI_MATKEY_UVWSRC_LIGHTMAP(0),&idx) && idx >= 1 && pcSource->mTextureCoords[idx]) {
|
|
sMacro[iCurrent].Name = "AV_TWO_UV";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
|
|
sMacro[iCurrent].Definition = "IN.TexCoord1";
|
|
}
|
|
else sMacro[iCurrent].Definition = "IN.TexCoord0";
|
|
sMacro[iCurrent].Name = "AV_LIGHTMAP_TEXTURE_UV_COORD";
|
|
|
|
++iCurrent;float f= 1.f;
|
|
aiGetMaterialFloat(pcMat,AI_MATKEY_TEXBLEND_LIGHTMAP(0),&f);
|
|
sprintf(buff,"%f",f);
|
|
|
|
sMacro[iCurrent].Name = "LM_STRENGTH";
|
|
sMacro[iCurrent].Definition = buff;
|
|
++iCurrent;
|
|
}
|
|
if (pcMesh->piNormalTexture && !bib)
|
|
{
|
|
sMacro[iCurrent].Name = "AV_NORMAL_TEXTURE";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
}
|
|
if (pcMesh->piOpacityTexture)
|
|
{
|
|
sMacro[iCurrent].Name = "AV_OPACITY_TEXTURE";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
|
|
if (pcMesh->piOpacityTexture == pcMesh->piDiffuseTexture)
|
|
{
|
|
sMacro[iCurrent].Name = "AV_OPACITY_TEXTURE_REGISTER_MASK";
|
|
sMacro[iCurrent].Definition = "a";
|
|
++iCurrent;
|
|
}
|
|
else
|
|
{
|
|
sMacro[iCurrent].Name = "AV_OPACITY_TEXTURE_REGISTER_MASK";
|
|
sMacro[iCurrent].Definition = "r";
|
|
++iCurrent;
|
|
}
|
|
}
|
|
|
|
if (pcMesh->eShadingMode != aiShadingMode_Gouraud && !g_sOptions.bNoSpecular)
|
|
{
|
|
sMacro[iCurrent].Name = "AV_SPECULAR_COMPONENT";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
|
|
if (pcMesh->piShininessTexture)
|
|
{
|
|
sMacro[iCurrent].Name = "AV_SHININESS_TEXTURE";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
}
|
|
}
|
|
if (1.0f != pcMesh->fOpacity)
|
|
{
|
|
sMacro[iCurrent].Name = "AV_OPACITY";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
}
|
|
|
|
if( pcSource->HasBones())
|
|
{
|
|
sMacro[iCurrent].Name = "AV_SKINNING";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
}
|
|
|
|
// If a cubemap is active, we'll need to lookup it for calculating
|
|
// a physically correct reflection
|
|
if (CBackgroundPainter::TEXTURE_CUBE == CBackgroundPainter::Instance().GetMode())
|
|
{
|
|
sMacro[iCurrent].Name = "AV_SKYBOX_LOOKUP";
|
|
sMacro[iCurrent].Definition = "1";
|
|
++iCurrent;
|
|
}
|
|
sMacro[iCurrent].Name = nullptr;
|
|
sMacro[iCurrent].Definition = nullptr;
|
|
|
|
// compile the shader
|
|
if(FAILED( D3DXCreateEffect(g_piDevice,
|
|
g_szMaterialShader.c_str(),(UINT)g_szMaterialShader.length(),
|
|
(const D3DXMACRO*)sMacro,nullptr,0,nullptr,&pcMesh->piEffect,&piBuffer)))
|
|
{
|
|
// failed to compile the shader
|
|
if( piBuffer)
|
|
{
|
|
MessageBox(g_hDlg,(LPCSTR)piBuffer->GetBufferPointer(),"HLSL",MB_OK);
|
|
piBuffer->Release();
|
|
}
|
|
// use the default material instead
|
|
if (g_piDefaultEffect)
|
|
{
|
|
pcMesh->piEffect = g_piDefaultEffect;
|
|
g_piDefaultEffect->AddRef();
|
|
}
|
|
|
|
// get the name of the material and use it in the log message
|
|
if(AI_SUCCESS == aiGetMaterialString(pcMat,AI_MATKEY_NAME,&szPath) &&
|
|
'\0' != szPath.data[0])
|
|
{
|
|
std::string sz = "[ERROR] Unable to load material: ";
|
|
sz.append(szPath.data);
|
|
CLogDisplay::Instance().AddEntry(sz);
|
|
}
|
|
else
|
|
{
|
|
CLogDisplay::Instance().AddEntry("Unable to load material: UNNAMED");
|
|
}
|
|
return 0;
|
|
} else
|
|
{
|
|
// use Fixed Function effect when working with shaderless cards
|
|
if( g_sCaps.PixelShaderVersion < D3DPS_VERSION(2,0))
|
|
pcMesh->piEffect->SetTechnique( "MaterialFX_FF");
|
|
}
|
|
|
|
if( piBuffer) piBuffer->Release();
|
|
|
|
|
|
// now commit all constants to the shader
|
|
//
|
|
// This is not necessary for shared shader. Shader constants for
|
|
// shared shaders are automatically recommited before the shader
|
|
// is being used for a particular mesh
|
|
|
|
if (1.0f != pcMesh->fOpacity)
|
|
pcMesh->piEffect->SetFloat("TRANSPARENCY",pcMesh->fOpacity);
|
|
if (pcMesh->eShadingMode != aiShadingMode_Gouraud && !g_sOptions.bNoSpecular)
|
|
{
|
|
pcMesh->piEffect->SetFloat("SPECULARITY",pcMesh->fShininess);
|
|
pcMesh->piEffect->SetFloat("SPECULAR_STRENGTH",pcMesh->fSpecularStrength);
|
|
}
|
|
|
|
pcMesh->piEffect->SetVector("DIFFUSE_COLOR",&pcMesh->vDiffuseColor);
|
|
pcMesh->piEffect->SetVector("SPECULAR_COLOR",&pcMesh->vSpecularColor);
|
|
pcMesh->piEffect->SetVector("AMBIENT_COLOR",&pcMesh->vAmbientColor);
|
|
pcMesh->piEffect->SetVector("EMISSIVE_COLOR",&pcMesh->vEmissiveColor);
|
|
|
|
if (pcMesh->piDiffuseTexture)
|
|
pcMesh->piEffect->SetTexture("DIFFUSE_TEXTURE",pcMesh->piDiffuseTexture);
|
|
if (pcMesh->piOpacityTexture)
|
|
pcMesh->piEffect->SetTexture("OPACITY_TEXTURE",pcMesh->piOpacityTexture);
|
|
if (pcMesh->piSpecularTexture)
|
|
pcMesh->piEffect->SetTexture("SPECULAR_TEXTURE",pcMesh->piSpecularTexture);
|
|
if (pcMesh->piAmbientTexture)
|
|
pcMesh->piEffect->SetTexture("AMBIENT_TEXTURE",pcMesh->piAmbientTexture);
|
|
if (pcMesh->piEmissiveTexture)
|
|
pcMesh->piEffect->SetTexture("EMISSIVE_TEXTURE",pcMesh->piEmissiveTexture);
|
|
if (pcMesh->piNormalTexture)
|
|
pcMesh->piEffect->SetTexture("NORMAL_TEXTURE",pcMesh->piNormalTexture);
|
|
if (pcMesh->piShininessTexture)
|
|
pcMesh->piEffect->SetTexture("SHININESS_TEXTURE",pcMesh->piShininessTexture);
|
|
if (pcMesh->piLightmapTexture)
|
|
pcMesh->piEffect->SetTexture("LIGHTMAP_TEXTURE",pcMesh->piLightmapTexture);
|
|
|
|
if (CBackgroundPainter::TEXTURE_CUBE == CBackgroundPainter::Instance().GetMode()){
|
|
pcMesh->piEffect->SetTexture("lw_tex_envmap",CBackgroundPainter::Instance().GetTexture());
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
int CMaterialManager::SetupMaterial (
|
|
AssetHelper::MeshHelper* pcMesh,
|
|
const aiMatrix4x4& pcProj,
|
|
const aiMatrix4x4& aiMe,
|
|
const aiMatrix4x4& pcCam,
|
|
const aiVector3D& vPos)
|
|
{
|
|
ai_assert(nullptr != pcMesh);
|
|
if (!pcMesh->piEffect)return 0;
|
|
|
|
ID3DXEffect* piEnd = pcMesh->piEffect;
|
|
|
|
piEnd->SetMatrix("WorldViewProjection",
|
|
(const D3DXMATRIX*)&pcProj);
|
|
|
|
piEnd->SetMatrix("World",(const D3DXMATRIX*)&aiMe);
|
|
piEnd->SetMatrix("WorldInverseTranspose",
|
|
(const D3DXMATRIX*)&pcCam);
|
|
|
|
D3DXVECTOR4 apcVec[5];
|
|
memset(apcVec,0,sizeof(apcVec));
|
|
apcVec[0].x = g_avLightDirs[0].x;
|
|
apcVec[0].y = g_avLightDirs[0].y;
|
|
apcVec[0].z = g_avLightDirs[0].z;
|
|
apcVec[0].w = 0.0f;
|
|
apcVec[1].x = g_avLightDirs[0].x * -1.0f;
|
|
apcVec[1].y = g_avLightDirs[0].y * -1.0f;
|
|
apcVec[1].z = g_avLightDirs[0].z * -1.0f;
|
|
apcVec[1].w = 0.0f;
|
|
D3DXVec4Normalize(&apcVec[0],&apcVec[0]);
|
|
D3DXVec4Normalize(&apcVec[1],&apcVec[1]);
|
|
piEnd->SetVectorArray("afLightDir",apcVec,5);
|
|
|
|
apcVec[0].x = ((g_avLightColors[0] >> 16) & 0xFF) / 255.0f;
|
|
apcVec[0].y = ((g_avLightColors[0] >> 8) & 0xFF) / 255.0f;
|
|
apcVec[0].z = ((g_avLightColors[0]) & 0xFF) / 255.0f;
|
|
apcVec[0].w = 1.0f;
|
|
|
|
if( g_sOptions.b3Lights)
|
|
{
|
|
apcVec[1].x = ((g_avLightColors[1] >> 16) & 0xFF) / 255.0f;
|
|
apcVec[1].y = ((g_avLightColors[1] >> 8) & 0xFF) / 255.0f;
|
|
apcVec[1].z = ((g_avLightColors[1]) & 0xFF) / 255.0f;
|
|
apcVec[1].w = 0.0f;
|
|
} else
|
|
{
|
|
apcVec[1].x = 0.0f;
|
|
apcVec[1].y = 0.0f;
|
|
apcVec[1].z = 0.0f;
|
|
apcVec[1].w = 0.0f;
|
|
}
|
|
|
|
apcVec[0] *= g_fLightIntensity;
|
|
apcVec[1] *= g_fLightIntensity;
|
|
piEnd->SetVectorArray("afLightColor",apcVec,5);
|
|
|
|
apcVec[0].x = ((g_avLightColors[2] >> 16) & 0xFF) / 255.0f;
|
|
apcVec[0].y = ((g_avLightColors[2] >> 8) & 0xFF) / 255.0f;
|
|
apcVec[0].z = ((g_avLightColors[2]) & 0xFF) / 255.0f;
|
|
apcVec[0].w = 1.0f;
|
|
|
|
apcVec[1].x = ((g_avLightColors[2] >> 16) & 0xFF) / 255.0f;
|
|
apcVec[1].y = ((g_avLightColors[2] >> 8) & 0xFF) / 255.0f;
|
|
apcVec[1].z = ((g_avLightColors[2]) & 0xFF) / 255.0f;
|
|
apcVec[1].w = 0.0f;
|
|
|
|
// FIX: light intensity doesn't apply to ambient color
|
|
//apcVec[0] *= g_fLightIntensity;
|
|
//apcVec[1] *= g_fLightIntensity;
|
|
piEnd->SetVectorArray("afLightColorAmbient",apcVec,5);
|
|
|
|
|
|
apcVec[0].x = vPos.x;
|
|
apcVec[0].y = vPos.y;
|
|
apcVec[0].z = vPos.z;
|
|
piEnd->SetVector( "vCameraPos",&apcVec[0]);
|
|
|
|
// if the effect instance is shared by multiple materials we need to
|
|
// recommit its whole state once per frame ...
|
|
if (pcMesh->bSharedFX)
|
|
{
|
|
// now commit all constants to the shader
|
|
if (1.0f != pcMesh->fOpacity)
|
|
pcMesh->piEffect->SetFloat("TRANSPARENCY",pcMesh->fOpacity);
|
|
if (pcMesh->eShadingMode != aiShadingMode_Gouraud)
|
|
{
|
|
pcMesh->piEffect->SetFloat("SPECULARITY",pcMesh->fShininess);
|
|
pcMesh->piEffect->SetFloat("SPECULAR_STRENGTH",pcMesh->fSpecularStrength);
|
|
}
|
|
|
|
pcMesh->piEffect->SetVector("DIFFUSE_COLOR",&pcMesh->vDiffuseColor);
|
|
pcMesh->piEffect->SetVector("SPECULAR_COLOR",&pcMesh->vSpecularColor);
|
|
pcMesh->piEffect->SetVector("AMBIENT_COLOR",&pcMesh->vAmbientColor);
|
|
pcMesh->piEffect->SetVector("EMISSIVE_COLOR",&pcMesh->vEmissiveColor);
|
|
|
|
if (pcMesh->piOpacityTexture)
|
|
pcMesh->piEffect->SetTexture("OPACITY_TEXTURE",pcMesh->piOpacityTexture);
|
|
if (pcMesh->piDiffuseTexture)
|
|
pcMesh->piEffect->SetTexture("DIFFUSE_TEXTURE",pcMesh->piDiffuseTexture);
|
|
if (pcMesh->piSpecularTexture)
|
|
pcMesh->piEffect->SetTexture("SPECULAR_TEXTURE",pcMesh->piSpecularTexture);
|
|
if (pcMesh->piAmbientTexture)
|
|
pcMesh->piEffect->SetTexture("AMBIENT_TEXTURE",pcMesh->piAmbientTexture);
|
|
if (pcMesh->piEmissiveTexture)
|
|
pcMesh->piEffect->SetTexture("EMISSIVE_TEXTURE",pcMesh->piEmissiveTexture);
|
|
if (pcMesh->piNormalTexture)
|
|
pcMesh->piEffect->SetTexture("NORMAL_TEXTURE",pcMesh->piNormalTexture);
|
|
if (pcMesh->piShininessTexture)
|
|
pcMesh->piEffect->SetTexture("SHININESS_TEXTURE",pcMesh->piShininessTexture);
|
|
if (pcMesh->piLightmapTexture)
|
|
pcMesh->piEffect->SetTexture("LIGHTMAP_TEXTURE",pcMesh->piLightmapTexture);
|
|
|
|
if (CBackgroundPainter::TEXTURE_CUBE == CBackgroundPainter::Instance().GetMode())
|
|
{
|
|
piEnd->SetTexture("lw_tex_envmap",CBackgroundPainter::Instance().GetTexture());
|
|
}
|
|
}
|
|
|
|
// disable culling, if necessary
|
|
if (pcMesh->twosided && g_sOptions.bCulling) {
|
|
g_piDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
|
|
}
|
|
|
|
// setup the correct shader technique to be used for drawing
|
|
if( g_sCaps.PixelShaderVersion < D3DPS_VERSION(2,0))
|
|
{
|
|
g_piDefaultEffect->SetTechnique( "MaterialFXSpecular_FF");
|
|
} else
|
|
if (g_sCaps.PixelShaderVersion < D3DPS_VERSION(3,0) || g_sOptions.bLowQuality)
|
|
{
|
|
if (g_sOptions.b3Lights)
|
|
piEnd->SetTechnique("MaterialFXSpecular_PS20_D2");
|
|
else piEnd->SetTechnique("MaterialFXSpecular_PS20_D1");
|
|
}
|
|
else
|
|
{
|
|
if (g_sOptions.b3Lights)
|
|
piEnd->SetTechnique("MaterialFXSpecular_D2");
|
|
else piEnd->SetTechnique("MaterialFXSpecular_D1");
|
|
}
|
|
|
|
// activate the effect
|
|
UINT dwPasses = 0;
|
|
piEnd->Begin(&dwPasses,0);
|
|
piEnd->BeginPass(0);
|
|
return 1;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
int CMaterialManager::EndMaterial (AssetHelper::MeshHelper* pcMesh)
|
|
{
|
|
ai_assert(nullptr != pcMesh);
|
|
if (!pcMesh->piEffect)return 0;
|
|
|
|
// end the effect
|
|
pcMesh->piEffect->EndPass();
|
|
pcMesh->piEffect->End();
|
|
|
|
// re-enable culling if necessary
|
|
if (pcMesh->twosided && g_sOptions.bCulling) {
|
|
g_piDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_CCW);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
} // end namespace AssimpView
|