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); }