void __fastcall SGameMtlPair::OnCommandClick(ButtonValue* V, bool& bModif, bool& bSafe)
{
bModif = false;
switch (V->btn_num){
case 0:{
LPCSTR MP=0;
SGameMtlPair* P = m_Owner->GetMaterialPair(ID_parent);
AnsiString nm = P?m_Owner->MtlPairToName(P->GetMtl0(),P->GetMtl1()):NONE_CAPTION;
if (TfrmChoseItem::SelectItem(smCustom,MP,128,0,fastdelegate::bind<TOnChooseFillItems>(this,&SGameMtlPair::FillChooseMtl))){
if (MP){
AStringVec lst;
_SequenceToList(lst,MP);
for (AStringIt it=lst.begin(); it!=lst.end(); it++){
int m0, m1;
m_Owner->NameToMtlPair (it->c_str(),m0,m1);
SGameMtlPair* p = m_Owner->GetMaterialPair(m0,m1); VERIFY(p);
if (!p->SetParent(GetID())){
ELog.DlgMsg(mtError,"Pair can't inherit from self.");
}else{
bModif = true;
}
}
if (bModif) ExecCommand(COMMAND_UPDATE_PROPERTIES);
}
}
}break;
}
}
void CGroupObject::OnShowHint(AStringVec& dest)
{
inherited::OnShowHint(dest);
dest.push_back(AnsiString("Reference: ")+m_ReferenceName_.c_str());
dest.push_back(AnsiString("-------"));
for (ObjectsInGroup::iterator it=m_ObjectsInGroup.begin(); it!=m_ObjectsInGroup.end(); ++it)
dest.push_back(it->pObject->Name);
}
void CGroupObject::OnShowHint(AStringVec& dest)
{
inherited::OnShowHint(dest);
dest.push_back(AnsiString("Reference: ")+m_ReferenceName.c_str());
dest.push_back(AnsiString("-------"));
for (ObjectIt it=m_Objects.begin(); it!=m_Objects.end(); it++)
dest.push_back((*it)->Name);
}
void TUI::ShowHint(const AnsiString& s)
{
VERIFY (m_bReady);
GetCursorPos (&m_HintPoint);
AStringVec SS;
SS.push_back (s);
Tools->OnShowHint(SS);
if (!ShowHint(SS)&&m_pHintWindow) HideHint();
}
int CSoundManager::GetSoundEnvs(AStringVec& items)
{
SoundEnvironment_LIB* Lib = Sound->get_env_library();
if (Lib){
for (SoundEnvironment_LIB::SE_IT it=Lib->Library().begin(); it!=Lib->Library().end(); it++)
items.push_back(*(*it)->name);
}
return items.size();
}
void _SequenceToList(AStringVec& lst, LPCSTR in, char separator)
{
lst.clear();
int t_cnt=_GetItemCount(in,separator);
AnsiString T;
for (int i=0; i<t_cnt; i++){
_GetItem(in,i,T,separator,0);
_Trim(T);
if (!T.IsEmpty()) lst.push_back(T);
}
}
AnsiString _ListToSequence(const AStringVec& lst)
{
AnsiString out;
out = "";
if (lst.size()){
out = lst.front();
for (AStringVec::const_iterator s_it=lst.begin()+1; s_it!=lst.end(); s_it++)
out += AnsiString(",")+(*s_it);
}
return out;
}
bool TUI::ShowHint(const AStringVec& SS)
{
VERIFY(m_bReady);
if (SS.size()){
AnsiString S=_ListToSequence2(SS);
if (m_bHintShowing&&(S==m_LastHint)) return true;
m_LastHint = S;
m_bHintShowing = true;
if (!m_pHintWindow){
m_pHintWindow = xr_new<THintWindow>((TComponent*)0);
m_pHintWindow->Brush->Color = (TColor)0x0d9F2FF;
}
TRect rect = m_pHintWindow->CalcHintRect(320,S,0);
rect.Left+=m_HintPoint.x; rect.Top+=m_HintPoint.y;
rect.Right+=m_HintPoint.x; rect.Bottom+=m_HintPoint.y;
m_pHintWindow->ActivateHint(rect,S);
}else{
m_bHintShowing = false;
m_LastHint = "";
}
return m_bHintShowing;
}
bool CEditableObject::Import_LWO(const char* fn, bool bNeedOptimize)
{
lwObject *I=0;
// UI->SetStatus("Importing...");
// UI->ProgressStart(100,"Read file:");
// UI->ProgressUpdate(1);
string512 fname;
strcpy(fname,fn);
#ifdef _EDITOR
I=LWO_ImportObject(fname,I);
#else
unsigned int failID;
int failpos;
I = lwGetObject( fname, &failID, &failpos );
#endif
// UI->ProgressUpdate(100);
if (I){
bool bResult=true;
ELog.Msg( mtInformation, "CEditableObject: import lwo %s...", fname );
// parse lwo object
{
m_Meshes.reserve (I->nlayers);
m_Surfaces.reserve (I->nsurfs);
// surfaces
st_lwSurface* Isf=0;
{
int i=0;
// UI->ProgressStart(I->nsurfs,"Check surf:");
for (Isf=I->surf; Isf; Isf=Isf->next){
// UI->ProgressUpdate(i);
Isf->alpha_mode=i; // перетираем для внутренних целей !!!
CSurface* Osf = new CSurface();
m_Surfaces.push_back(Osf);
if (Isf->name&&Isf->name[0]) Osf->SetName(Isf->name); else Osf->SetName("Default");
Osf->m_Flags.set(CSurface::sf2Sided,(Isf->sideflags==3)?TRUE:FALSE);
AnsiString en_name="default", lc_name="default", gm_name="default";
XRShader* sh_info = 0;
if (Isf->nshaders&&(stricmp(Isf->shader->name,SH_PLUGIN_NAME)==0)){
sh_info = (XRShader*)Isf->shader->data;
en_name = sh_info->en_name;
lc_name = sh_info->lc_name;
gm_name = sh_info->gm_name;
}else
ELog.Msg(mtError,"CEditableObject: Shader not found on surface '%s'.",Osf->_Name());
#ifdef _EDITOR
if (!Device.Resources->_FindBlender(en_name.c_str())){
ELog.Msg(mtError,"CEditableObject: Render shader '%s' - can't find in library.\nUsing 'default' shader on surface '%s'.", en_name.c_str(), Osf->_Name());
en_name = "default";
}
if (!Device.ShaderXRLC.Get(lc_name.c_str())){
ELog.Msg(mtError,"CEditableObject: Compiler shader '%s' - can't find in library.\nUsing 'default' shader on surface '%s'.", lc_name.c_str(), Osf->_Name());
lc_name = "default";
}
if (!GMLib.GetMaterial(gm_name.c_str())){
ELog.Msg(mtError,"CEditableObject: Game material '%s' - can't find in library.\nUsing 'default' material on surface '%s'.", lc_name.c_str(), Osf->_Name());
gm_name = "default";
}
#endif
// fill texture layers
int cidx;
st_lwClip* Icl;
u32 dwNumTextures=0;
for (st_lwTexture* Itx=Isf->color.tex; Itx; Itx=Itx->next){
string1024 tname="";
dwNumTextures++;
cidx = -1;
if (Itx->type==ID_IMAP) cidx=Itx->param.imap.cindex;
else{
ELog.DlgMsg(mtError, "Import LWO (Surface '%s'): 'Texture' is not Image Map!",Osf->_Name());
bResult=false;
break;
}
if (cidx!=-1){
// get textures
for (Icl=I->clip; Icl; Icl=Icl->next)
if ((cidx==Icl->index)&&(Icl->type==ID_STIL)){
strcpy(tname,Icl->source.still.name);
break;
}
if (tname[0]==0){
ELog.DlgMsg(mtError, "Import LWO (Surface '%s'): 'Texture' name is empty or non 'STIL' type!",Osf->_Name());
bResult=false;
break;
}
string256 tex_name;
_splitpath( tname, 0, 0, tex_name, 0 );
Osf->SetTexture(EFS.AppendFolderToName(tex_name,1,TRUE));
// get vmap refs
Osf->SetVMap(Itx->param.imap.vmap_name);
}
}
if (!bResult) break;
if (!Osf->_VMap()||!Osf->_VMap()[0]){
ELog.DlgMsg(mtError, "Invalid surface '%s'. VMap empty.",Osf->_Name());
bResult = false;
break;
}
if (!Osf->_Texture()||!Osf->_Texture()[0]){
ELog.DlgMsg(mtError, "Can't create shader. Invalid surface '%s'. Textures empty.",Osf->_Name());
bResult = false;
break;
}
if (en_name.c_str()==0){
ELog.DlgMsg(mtError, "Can't create shader. Invalid surface '%s'. Shader empty.",Osf->_Name());
bResult = false;
break;
}
Osf->SetShader (en_name.c_str());
Osf->SetShaderXRLC (lc_name.c_str());
Osf->SetGameMtl (gm_name.c_str());
Osf->SetFVF (D3DFVF_XYZ|D3DFVF_NORMAL|(dwNumTextures<<D3DFVF_TEXCOUNT_SHIFT));
i++;
}
}
if (bResult){
// mesh layers
st_lwLayer* Ilr=0;
int k=0;
for (Ilr=I->layer; Ilr; Ilr=Ilr->next){
// create new mesh
CEditableMesh* MESH= new CEditableMesh(this);
m_Meshes.push_back(MESH);
if (Ilr->name) MESH->SetName(Ilr->name); else MESH->SetName("");
MESH->m_Box.set(Ilr->bbox[0],Ilr->bbox[1],Ilr->bbox[2], Ilr->bbox[3],Ilr->bbox[4],Ilr->bbox[5]);
// parse mesh(lwo-layer) data
// vmaps
st_lwVMap* Ivmap=0;
int vmap_count=0;
if (Ilr->nvmaps==0){
ELog.DlgMsg(mtError, "Import LWO: Mesh layer must contain UV!");
bResult=false;
break;
}
// индексы соответствия импортируемых мап
static VMIndexLink VMIndices;
VMIndices.clear();
for (Ivmap=Ilr->vmap; Ivmap; Ivmap=Ivmap->next){
switch(Ivmap->type){
case ID_TXUV:{
if (Ivmap->dim!=2){
ELog.DlgMsg(mtError, "Import LWO: 'UV Map' must contain 2 value!");
bResult=false;
break;
}
MESH->m_VMaps.push_back(new st_VMap(Ivmap->name,vmtUV,!!Ivmap->perpoly));
st_VMap* Mvmap=MESH->m_VMaps.back();
int vcnt=Ivmap->nverts;
// VMap
Mvmap->copyfrom(*Ivmap->val,vcnt);
// flip uv
for (int k=0; k<Mvmap->size(); k++){
Fvector2& uv = Mvmap->getUV(k);
uv.y=1.f-uv.y;
}
// vmap index
VMIndices[Ivmap] = vmap_count++;
}break;
case ID_WGHT:{
if (Ivmap->dim!=1){
ELog.DlgMsg(mtError, "Import LWO: 'Weight' must contain 1 value!");
bResult=false;
break;
}
MESH->m_VMaps.push_back(new st_VMap(Ivmap->name,vmtWeight,false));
st_VMap* Mvmap=MESH->m_VMaps.back();
int vcnt=Ivmap->nverts;
// VMap
Mvmap->copyfrom(*Ivmap->val,vcnt);
// vmap index
VMIndices[Ivmap] = vmap_count++;
}break;
case ID_PICK: ELog.Msg(mtError,"Found 'PICK' VMAP. Import failed."); bResult = false; break;
case ID_MNVW: ELog.Msg(mtError,"Found 'MNVW' VMAP. Import failed."); bResult = false; break;
case ID_MORF: ELog.Msg(mtError,"Found 'MORF' VMAP. Import failed."); bResult = false; break;
case ID_SPOT: ELog.Msg(mtError,"Found 'SPOT' VMAP. Import failed."); bResult = false; break;
case ID_RGB: ELog.Msg(mtError,"Found 'RGB' VMAP. Import failed."); bResult = false; break;
case ID_RGBA: ELog.Msg(mtError,"Found 'RGBA' VMAP. Import failed."); bResult = false; break;
}
if (!bResult) break;
}
if (!bResult) break;
// points
// UI->ProgressStart(Ilr->point.count,"Fill points:");
{
MESH->m_VertCount = Ilr->point.count;
MESH->m_Vertices = xr_alloc<Fvector>(MESH->m_VertCount);
int id = Ilr->polygon.count/50;
if (id==0)
id = 1;
for (int i=0; i<Ilr->point.count; ++i)
{
st_lwPoint& Ipt = Ilr->point.pt[i];
Fvector& Mpt = MESH->m_Vertices[i];
Mpt.set (Ipt.pos);
}
}
if (!bResult) break;
// polygons
MESH->m_FaceCount = Ilr->polygon.count;
MESH->m_Faces = xr_alloc<st_Face>(MESH->m_FaceCount);
MESH->m_SmoothGroups = xr_alloc<u32>(MESH->m_FaceCount);
Memory.mem_fill32 (MESH->m_SmoothGroups,u32(-1),MESH->m_FaceCount);
MESH->m_VMRefs.reserve (Ilr->polygon.count*3);
IntVec surf_ids;
surf_ids.resize(Ilr->polygon.count);
int id = Ilr->polygon.count/50;
if (id==0)
id = 1;
for (int i=0; i<Ilr->polygon.count; ++i)
{
st_Face& Mpol=MESH->m_Faces[i];
st_lwPolygon& Ipol=Ilr->polygon.pol[i];
if (Ipol.nverts!=3) {
ELog.DlgMsg(mtError, "Import LWO: Face must contain only 3 vertices!");
bResult=false;
break;
}
for (int pv_i=0; pv_i<3; ++pv_i)
{
st_lwPolVert& Ipv=Ipol.v[pv_i];
st_FaceVert& Mpv=Mpol.pv[pv_i];
Mpv.pindex =Ipv.index;
MESH->m_VMRefs.push_back(st_VMapPtLst());
st_VMapPtLst& m_vm_lst = MESH->m_VMRefs.back();
DEFINE_VECTOR (st_VMapPt,VMapPtVec,VMapPtIt);
VMapPtVec vm_lst;
Mpv.vmref = MESH->m_VMRefs.size()-1;
// parse uv-map
int vmpl_cnt =Ipv.nvmaps;
st_lwPoint& Ipt =Ilr->point.pt[Mpv.pindex];
int vmpt_cnt =Ipt.nvmaps;
if (!vmpl_cnt&&!vmpt_cnt){
ELog.DlgMsg (mtError,"Found mesh without UV's!",0);
bResult = false;
break;
}
AStringVec names;
if (vmpl_cnt){
// берем из poly
for (int vm_i=0; vm_i<vmpl_cnt; vm_i++){
if (Ipv.vm[vm_i].vmap->type!=ID_TXUV) continue;
vm_lst.push_back(st_VMapPt());
st_VMapPt& pt = vm_lst.back();
pt.vmap_index = VMIndices[Ipv.vm[vm_i].vmap];// номер моей VMap
names.push_back (Ipv.vm[vm_i].vmap->name);
pt.index = Ipv.vm[vm_i].index;
}
}
if (vmpt_cnt){
// берем из points
for (int vm_i=0; vm_i<vmpt_cnt; vm_i++){
if (Ipt.vm[vm_i].vmap->type!=ID_TXUV) continue;
if (std::find(names.begin(),names.end(),Ipt.vm[vm_i].vmap->name)!=names.end()) continue;
vm_lst.push_back(st_VMapPt());
st_VMapPt& pt = vm_lst.back();
pt.vmap_index = VMIndices[Ipt.vm[vm_i].vmap]; // номер моей VMap
pt.index = Ipt.vm[vm_i].index;
}
}
std::sort(vm_lst.begin(),vm_lst.end(),CompareFunc);
// parse weight-map
int vm_cnt =Ipt.nvmaps;
for (int vm_i=0; vm_i<vm_cnt; vm_i++){
if (Ipt.vm[vm_i].vmap->type!=ID_WGHT) continue;
vm_lst.push_back(st_VMapPt());
st_VMapPt& pt = vm_lst.back();
pt.vmap_index = VMIndices[Ipt.vm[vm_i].vmap]; // номер моей VMap
pt.index = Ipt.vm[vm_i].index;
}
m_vm_lst.count = vm_lst.size();
m_vm_lst.pts = xr_alloc<st_VMapPt>(m_vm_lst.count);
Memory.mem_copy (m_vm_lst.pts,&*vm_lst.begin(),m_vm_lst.count*sizeof(st_VMapPt));
}
if (!bResult) break;
// Ipol.surf->alpha_mode - заполнено как номер моего surface
surf_ids[i] = Ipol.surf->alpha_mode;
}
if (!bResult) break;
for (u32 pl_id=0; pl_id<MESH->GetFCount(); pl_id++)
MESH->m_SurfFaces[m_Surfaces[surf_ids[pl_id]]].push_back(pl_id);
if (!bResult) break;
k++;
//MESH->DumpAdjacency();
if (bNeedOptimize) MESH->OptimizeMesh(false);
//MESH->DumpAdjacency();
MESH->RebuildVMaps(); // !!!!!!
}
}
}
#ifdef _EDITOR
LWO_CloseFile(I);
#else
lwFreeObject(I);
#endif
// UI->ProgressEnd();
// UI->SetStatus("");
if (bResult) VerifyMeshNames();
else ELog.DlgMsg(mtError,"Can't parse LWO object.");
if (bResult) m_LoadName = (strext(fname))? strcpy(strext(fname),".object"):strcat(strext(fname),".object");
return bResult;
}else
ELog.DlgMsg(mtError,"Can't import LWO object file.");
// UI->ProgressEnd();
// UI->SetStatus("");
return false;
}
void CSceneObject::OnShowHint(AStringVec& dest)
{
inherited::OnShowHint(dest);
dest.push_back(AnsiString("Reference: ")+*m_ReferenceName);
dest.push_back(AnsiString("-------"));
float dist = UI->ZFar();
SRayPickInfo pinf;
if (m_pReference->RayPick(dist,UI->m_CurrentRStart,UI->m_CurrentRNorm,_ITransform(),&pinf)){
dest.push_back(AnsiString("Object Type: ")+get_token_name(eo_type_token,pinf.e_obj->m_Flags.flags));
R_ASSERT(pinf.e_mesh);
CSurface* surf=pinf.e_mesh->GetSurfaceByFaceID(pinf.inf.id);
dest.push_back(AnsiString("Surface: ")+AnsiString(surf->_Name()));
dest.push_back(AnsiString("2 Sided: ")+AnsiString(surf->m_Flags.is(CSurface::sf2Sided)?"on":"off"));
if (pinf.e_obj->m_Flags.is(CEditableObject::eoSoundOccluder)){
dest.push_back(AnsiString("Game Mtl: ")+AnsiString(surf->_GameMtlName()));
int gm_id = surf->_GameMtl();
if (gm_id!=GAMEMTL_NONE_ID){
SGameMtl* mtl = GMLib.GetMaterialByID(gm_id);
if (mtl) dest.push_back(AnsiString().sprintf("Occlusion Factor: %3.2f",mtl->fSndOcclusionFactor));
}
}else if (pinf.e_obj->m_Flags.is(CEditableObject::eoHOM)){
}else{
dest.push_back(AnsiString("Texture: ")+AnsiString(surf->_Texture()));
dest.push_back(AnsiString("Shader: ")+AnsiString(surf->_ShaderName()));
dest.push_back(AnsiString("LC Shader: ")+AnsiString(surf->_ShaderXRLCName()));
dest.push_back(AnsiString("Game Mtl: ")+AnsiString(surf->_GameMtlName()));
}
}
}
