bool CStaticMesh::Reload()
{
ClearTextures();
Unload();
FILE* modelFile = NULL;
fopen_s(&modelFile, m_FileName.c_str(), "rb");
if(modelFile == NULL)
{
return false;
}
uint16 tmp = 0;
//Read Header
fread(&tmp, sizeof(uint16), 1, modelFile);
if(tmp != 0xCACA)
{
//header was not present, file type not valid
fclose(modelFile);
return false;
}
//Extract Mesh from File
if(!ExtractMesh(modelFile))
{
ClearTextures();
Unload();
fclose(modelFile);
return false;
}
//Extract Bounding Box and Sphere from File
if(!GetBoundingBoxAndSphere(modelFile))
{
ClearTextures();
Unload();
fclose(modelFile);
return false;
}
fclose(modelFile);
if(!GetRenderableObjectTechnique())
{
ClearTextures();
Unload();
return false;
}
GetTextureNames();
return true;
}
static void
DialogClose(GtkDialog * UNUSED(dialog), gint response, void *UNUSED(data))
{
if ((GtkResponseType) response == GTK_RESPONSE_OK) { /* Apply new settings */
char *texStr;
/* Copy new settings to preview material */
curDetails->mat = col3d;
*curDetails->pBoardMat = col3d;
if (useTexture) {
texStr = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(textureComboBox));
if (!strcmp(texStr, NO_TEXTURE_STRING))
col3d.textureInfo = 0;
else {
BoardData *bd = (BOARD(pwPrevBoard))->board_data;
ClearTextures(bd->bd3d);
GetTextures(bd->bd3d, bd->rd);
}
}
UpdatePreview();
gtk_widget_queue_draw(curDetails->preview);
}
/* Hide dialog so can be reshown quickly */
gtk_widget_hide(pwColourDialog3d);
}
void CMainWindow::LoadModel()
{
std::string modelPath = QFileDialog::getOpenFileName(this,
"Open Model",
"",
g_GetSupported3DFormats()).toStdString();
if(modelPath.empty())
return;
try
{
CMesh *newModel = new CMesh();
newModel->LoadMesh(modelPath);
AskToSaveChanges();
m_openedModel = "";
m_rw2->SetModel(newModel);
m_rw3->SetModel(newModel);
if(m_model)
delete m_model;
m_model = newModel;
ClearTextures();
m_rw2->ZoomFit();
m_rw3->ZoomFit();
UpdateView();
} catch(std::exception& e)
{
ClearModel();
QMessageBox::information(this, "Error", e.what());
}
}
void C3d::Open(const TriFile &tfile)
{
Cleanup();
rotation = true;
if( FAILED( g_pd3dDevice->CreateVertexBuffer(tfile.header.numVertices*sizeof(CUSTOMVERTEX), 0, D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &g_pVB, NULL)))
return;
CUSTOMVERTEX* pVertices;
if( FAILED( g_pVB->Lock( 0, 0, (void**)&pVertices, 0 ) ) )
return;
vcount = tfile.header.numVertices;
if(tfile.hasTangentsBinormals)
{
for( DWORD i=0; i<tfile.header.numVertices; i++ )
{
pVertices[i].position = tfile.verticestb(i)->vertexPosition;
pVertices[i].normal = tfile.verticestb(i)->vertexNormal;
pVertices[i].uv = tfile.verticestb(i)->vertexUV;
}
}else{
for( DWORD i=0; i<tfile.header.numVertices; i++ )
{
pVertices[i].position = tfile.verticesc(i)->vertexPosition;
pVertices[i].normal = tfile.verticesc(i)->vertexNormal;
pVertices[i].uv = tfile.verticesc(i)->vertexUV;
}
}
ComputeBoundingSphere(pVertices, vcount, &vCenter, &vRadius);
g_pVB->Unlock();
D3DVIEWPORT9 vp;
g_pd3dDevice->GetViewport(&vp);
vp.MinZ = -((int)vRadius/300)*55.0f;
g_pd3dDevice->SetViewport(&vp);
D3DXMatrixIdentity( &matWorld );
MatrixTranslation( &matWorld, vCenter.x, -vCenter.y, -vCenter.z );
DWORD *indices=NULL;
ClearIndexes();
ClearTextures();
g_pTexture.resize(tfile.header.numSurfaces);
for(unsigned int i = 0; i < tfile.header.numSurfaces; i++)
g_pTexture[i] = NULL;
g_pIB.resize(tfile.header.numSurfaces);
fcount.resize(tfile.header.numSurfaces);
for(dword i = 0; i < tfile.header.numSurfaces; i++)
{
g_pd3dDevice->CreateIndexBuffer(tfile.surfaces[i].numTriangles*3*4,D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_MANAGED, &g_pIB[i], NULL);
g_pIB[i]->Lock( 0, 0, (void**)&indices, 0 );
for(dword c = 0; c < tfile.surfaces[i].numTriangles; c++)
{
indices[3*c] = tfile.triangles[i][c][0];
indices[3*c+1] = tfile.triangles[i][c][1];
indices[3*c+2] = tfile.triangles[i][c][2];
}
g_pIB[i]->Unlock();
fcount[i] = tfile.surfaces[i].numTriangles;
}
loaded = true;
}
LRESULT C3d::OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
//SAFE_RELEASE(mSwapChain);
//SAFE_RELEASE(mDepthStencil);
SAFE_RELEASE(g_pD3D);
ClearTextures();
Cleanup();
return TRUE;
}
void CMainWindow::ClearModel()
{
m_openedModel = "";
if(m_model)
delete m_model;
m_model = nullptr;
m_rw2->SetModel(nullptr);
m_rw3->SetModel(nullptr);
m_rw2->ClearSheets();
ClearTextures();
}
//--
//
// ClearAll
//
//--
void Mesh::ClearAll()
{
// Initialize mesh
// Clear all data
ClearVertices();
ClearFaces();
ClearColors();
ClearTextures();
ClearFaceNormals();
ClearVertexNormals();
ClearTextureName();
}
void C3d::TextureChange(const StuffFile &sf,const vector<int> &textures)
{
ClearTextures();
for(unsigned int i=0; i < g_pTexture.size(); i++)
{
int index = textures[i];
g_pTexture[i] = NULL;
if(index > -1)
{
vector<byte> data;
data.resize(sf.files[index].fileSize);
sf.files[index].handle->seekg(sf.files[index].fileOffset);
sf.files[index].handle->read(reinterpret_cast<char*>(&data[0]), sf.files[index].fileSize);
LPDIRECT3DTEXTURE9 tmp;
if(LoadTextureFromMemory(g_pd3dDevice, &data[0], &tmp))
g_pTexture[i] = tmp;
}
}
}
CacheSettingsWidget::CacheSettingsWidget(QObject *settings_object) :
QWidget(0, Qt::Widget),
current_textures_cache_everything_(false),
current_textures_max_size_(0),
current_assets_max_size_(0)
{
setupUi(this);
ReadConfig();
// Set read config values to ui
SetTextureConfigValues(current_textures_max_size_, current_textures_cache_everything_);
SetAssetConfigValues(current_assets_max_size_);
connect(settings_object, SIGNAL(SaveSettingsClicked()),
SLOT(SettingsSaved()));
connect(pushButton_clear_assets, SIGNAL(clicked()),
SLOT(ClearAssets()));
connect(pushButton_clear_textures, SIGNAL(clicked()),
SLOT(ClearTextures()));
}
void Lighting::SetShader(RenderLightType Type, ShaderMat *Mat)
{
switch(Mat->m_LightGroup)
{
default:
if(Type == LIGHT_OMNI)
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_OMNI]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_OMNI]);
ClearTextures();
SetAttenMap();
SetCubeNormal(NORMALIZE_ZERO | NORMALIZE_ONE);
}
else if(Type == LIGHT_SPOT)
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_SPOT]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_SPOT]);
ClearTextures();
SetSpotMap();
SetCubeNormal(NORMALIZE_ZERO | NORMALIZE_ONE);
}
else
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_DIR]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_DIR]);
ClearTextures();
SetCubeNormal(NORMALIZE_ZERO | NORMALIZE_ONE);
}
break;
case LG_NORMALSPEC:
if(Type == LIGHT_OMNI)
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_OMNI_NORMAL_SPEC]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_OMNI_NORMAL_SPEC]);
ClearTextures();
SetAttenMap();
Mat->SetChannelsLight(m_Device);
}
else if(Type == LIGHT_SPOT)
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_SPOT_NORMAL_SPEC]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_SPOT_NORMAL_SPEC]);
ClearTextures();
Mat->SetChannelsLight(m_Device);
SetSpotMap();
}
else
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_DIR_NORMAL_SPEC]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_DIR_NORMAL_SPEC]);
ClearTextures();
Mat->SetChannelsLight(m_Device);
}
break;
case LG_NORMAL:
if(Type == LIGHT_OMNI)
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_OMNI_NORMAL]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_OMNI_NORMAL]);
ClearTextures();
Mat->SetChannelsLight(m_Device);
SetAttenMap();
SetCubeNormal(NORMALIZE_ONE);
}
else if(Type == LIGHT_SPOT)
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_SPOT_NORMAL]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_SPOT_NORMAL]);
ClearTextures();
Mat->SetChannelsLight(m_Device);
SetSpotMap();
SetCubeNormal(NORMALIZE_ONE);
}
else
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_DIR_NORMAL]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_DIR_NORMAL]);
ClearTextures();
Mat->SetChannelsLight(m_Device);
SetCubeNormal(NORMALIZE_ONE);
}
break;
case LG_SPEC:
if(Type == LIGHT_OMNI)
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_OMNI_SPEC]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_OMNI_SPEC]);
ClearTextures();
SetAttenMap();
Mat->SetChannelsLight(m_Device);
SetCubeNormal(NORMALIZE_ZERO);
}
else if(Type == LIGHT_SPOT)
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_SPOT_SPEC]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_SPOT_SPEC]);
ClearTextures();
Mat->SetChannelsLight(m_Device);
SetSpotMap();
SetCubeNormal(NORMALIZE_ZERO);
}
else
{
m_Device->SetVertexShader(m_VertexHandle[SHADER_DIR_SPEC]);
m_Device->SetPixelShader(m_PixelHandle[SHADER_DIR_SPEC]);
ClearTextures();
Mat->SetChannelsLight(m_Device);
SetCubeNormal(NORMALIZE_ZERO);
}
break;
}
}
void Material::Configure(PersistentData& storageData)
{
mUseRenderTarget = false;
mDiffuse = storageData.GetColorChild("Diffuse");
mSpecular = storageData.GetColorChild("Specular");
mAmbient = storageData.GetColorChild("Ambient");
mEmissive = storageData.GetColorChild("Emissive");
mColorMask = storageData.GetColorChild("ColorMask");
if(mColorMask != IvColor::white)
{
mUseColorMask = true;
}
mZWrite = !storageData.GetPropertyB("DisableZWrite");
mZTest = !storageData.GetPropertyB("DisableZTest");
PersistentData* texturesParent = storageData.GetNodeFromPath("Textures");
if(texturesParent != NULL)
{
ClearTextures();
std::list<PersistentData*> textures;
texturesParent->GetNodesFromPath("Texture",textures);
std::list<PersistentData*>::iterator txtIt = textures.begin();
while(txtIt != textures.end())
{
PersistentData* txNode = *txtIt;
//////////////////////////
mRenderTargetTag = txNode->GetProperty("UseRenderTarget");
if(mRenderTargetTag.empty() == false)
{
RenderTarget* rt = (RenderTarget*)Game::GetInstance().GetTaggedObject(mRenderTargetTag);
if(rt != NULL)
{
mUseRenderTarget = true;
AddTexture(rt->GetTextureID());
}
else
{
printf("ERROR: Material '%s' wants to use non-existent render target: %s\n",mName.c_str(),mRenderTargetTag.c_str());
}
}
else
{
std::string imagename = txNode->GetProperty("ImageName");
bool delayLoad = txNode->GetPropertyB("DelayLoad");
GameID texID = RendererObjectFactory::CreateTexture(imagename.c_str(),imagename.c_str(),delayLoad);
AddTexture(texID);
}
//////////////////////////
++txtIt;
}
}
PersistentData* tmParent = storageData.GetNodeFromPath("TextureMatrices");
if(tmParent != NULL)
{
std::list<PersistentData*> textureMatrices;
tmParent->GetNodesFromPath("TextureMatrix",textureMatrices);
IvVector3 pos, scale, rot;
int idx = 0;
std::list<PersistentData*>::iterator tmNodeIt = textureMatrices.begin();
while(tmNodeIt != textureMatrices.end())
{
PersistentData* tmNode =*tmNodeIt;
if(tmNode != NULL){
//mUseTextureMatrix = true;
if(tmNode->GetNodeFromPath("Position") != NULL)
{
pos = tmNode->GetVector3Child("Position");
TranslateTextureMatrix(pos,idx);
}
if(storageData.GetNodeFromPath("Rotation") != NULL)
{
rot = tmNode->GetVector3Child("Rotation");
RotateTextureMatrix(rot.x,rot.y,rot.z,idx);
}
if(tmNode->GetNodeFromPath("Scale") != NULL)
{
scale = tmNode->GetVector3Child("Scale");
ScaleTextureMatrix(scale,idx);
}
}
++idx;
++tmNodeIt;
}
}
PersistentData* tc = storageData.GetNodeFromPath("TextureCombiners");
if(tc != NULL)
{
ConfigureCombiners(*tc);
}
std::string blendFunc;
Renderer& rend = Game::GetInstance().GetRenderer();
PersistentData* blend = storageData.GetNodeFromPath("Blend");
mBlend = blend->GetPropertyB("Enabled");
blendFunc = blend->GetProperty("FuncA");
mBlendFuncA = rend.GetEnumForString(blendFunc);
blendFunc = blend->GetProperty("FuncB");
mBlendFuncB = rend.GetEnumForString(blendFunc);
std::string alphaFunc;
PersistentData* alphaTest = storageData.GetNodeFromPath("AlphaTest");
if(alphaTest != NULL)
{
mUseAlphaTest = alphaTest->GetPropertyB("Enabled");
mAlphaFuncTestValue = alphaTest->GetPropertyF("value");
alphaFunc = alphaTest->GetProperty("Func");
mAlphaFunc = rend.GetEnumForString(alphaFunc);
}
/*
//Causes Crash on 3.0 Release but not 3.0 debug
PersistentData* shaderInfo = storageData.GetNodeFromPath("Shaders");
if(shaderInfo != NULL)
{
mVertexShaderPath = shaderInfo->GetProperty("vertex");
mFragmentShaderPath = shaderInfo->GetProperty("fragment");
SetupShaders();
}*/
}
void TextureManager::Cleanup()
{
ClearTextNode();
ClearTextures();
}
void CMainWindow::LoadFromIVO(const char* filename)
{
FILE* f = std::fopen(filename, "rb");
if(!f)
BadFile(f);
char ivo[4];
int version = -1;
SAFE_FREAD(ivo, sizeof(char), 3, f);
ivo[3] = '\0';
if(strcmp(ivo, "IVO") != 0)
{
QMessageBox::information(this, "Error", "Selected file is not a valid IVO model!");
std::fclose(f);
return;
}
SAFE_FREAD(&version, sizeof(version), 1, f);
switch(version)
{
case 1 :
{
unsigned char renFlags;
unsigned paperWid;
unsigned paperHei;
float resScale;
int imageFmt;
unsigned char imageQlt;
float lineWidt;
unsigned stipplLp;
SAFE_FREAD(&renFlags, sizeof(renFlags), 1, f);
SAFE_FREAD(&paperWid, sizeof(paperWid), 1, f);
SAFE_FREAD(&paperHei, sizeof(paperHei), 1, f);
SAFE_FREAD(&resScale, sizeof(resScale), 1, f);
SAFE_FREAD(&imageFmt, sizeof(imageFmt), 1, f);
SAFE_FREAD(&imageQlt, sizeof(imageQlt), 1, f);
SAFE_FREAD(&lineWidt, sizeof(lineWidt), 1, f);
SAFE_FREAD(&stipplLp, sizeof(stipplLp), 1, f);
std::unique_ptr<CMesh> newModelUP(new CMesh());
newModelUP->Deserialize(f);
CMesh* newModel = newModelUP.release();
m_openedModel = filename;
m_rw2->SetModel(newModel);
((IRenWin*)m_rw3)->SetModel(newModel);
if(m_model)
delete m_model;
m_model = newModel;
ClearTextures();
m_rw2->DeserializeSheets(f);
m_rw2->UpdateSheetsSize();
std::unordered_map<unsigned, std::string> materials;
unsigned char numTextures = 0;
SAFE_FREAD(&numTextures, sizeof(numTextures), 1, f);
for(int i=numTextures-1; i>=0; i--)
{
unsigned key;
int nameLen;
int pathLen;
SAFE_FREAD(&key, sizeof(key), 1, f);
SAFE_FREAD(&nameLen, sizeof(nameLen), 1, f);
std::unique_ptr<char[]> name(new char[nameLen+1]);
name[nameLen] = '\0';
SAFE_FREAD(name.get(), sizeof(char), nameLen, f);
SAFE_FREAD(&pathLen, sizeof(pathLen), 1, f);
std::unique_ptr<char[]> path(new char[pathLen+1]);
path[pathLen] = '\0';
SAFE_FREAD(path.get(), sizeof(char), pathLen, f);
int hasTexture = 0;
SAFE_FREAD(&hasTexture, sizeof(hasTexture), 1, f);
if(hasTexture == 1)
{
int texWidth = 0;
int texHeight = 0;
int texByteCount = 0;
int texFormat = 0;
SAFE_FREAD(&texWidth, sizeof(texWidth), 1, f);
SAFE_FREAD(&texHeight, sizeof(texHeight), 1, f);
SAFE_FREAD(&texByteCount, sizeof(texByteCount), 1, f);
SAFE_FREAD(&texFormat, sizeof(texFormat), 1, f);
std::unique_ptr<unsigned char[]> imgBits(new unsigned char[texByteCount]);
SAFE_FREAD(imgBits.get(), sizeof(unsigned char), texByteCount, f);
m_textureImages[key].reset(new QImage(imgBits.get(), texWidth, texHeight, (QImage::Format)texFormat));
(*m_textureImages[key]) = m_textureImages[key]->copy();
}
materials[key] = name.get();
m_textures[key] = path.get();
m_rw2->ReserveTextureID(key);
((IRenWin*)m_rw3)->ReserveTextureID(key);
if(hasTexture == 1)
emit UpdateTexture(m_textureImages[key].get(), key);
}
m_model->SetMaterials(materials);
CSettings& sett = CSettings::GetInstance();
sett.SetRenderFlags( renFlags );
sett.SetPaperWidth( paperWid );
sett.SetPaperHeight( paperHei );
sett.SetResolutionScale( resScale );
sett.SetImageFormat( (CSettings::ImageFormat)imageFmt );
sett.SetImageQuality( imageQlt );
sett.SetLineWidth( lineWidt );
sett.SetStippleLoop( stipplLp );
m_rw2->UpdateSheetsSize();
break;
}
default :
{
QMessageBox::information(this, "Error", "Ivo format version " + QString::number(version) + " is not supported by this version of program!");
}
}
std::fclose(f);
}
