public MaterialViewModel(IMessageBoxService messageBoxService, IMaterialManager manager, IMaterialGroupManager groupManager, IUnitManager unitManager) : base(messageBoxService, manager)
{
// do initialization
try
{
if (groupManager == null)
{
throw new ArgumentNullException("groupManager");
}
_groupManager = groupManager;
// populate the list of groups
this.GroupList = _groupManager.GetList();
if (unitManager == null)
{
throw new ArgumentNullException("unitManager");
}
_unitManager = unitManager;
// populate the list of units
this.UnitList = _unitManager.GetList();
this.DisplayName = "Create Material";
}
catch (Exception ex)
{
this.MessageBoxService.ShowError(this.GetType().FullName + System.Reflection.MethodBase.GetCurrentMethod().Name + ": " + ex.Message);
}
}
public LightingManager(IGameContext gameContext,
IGameProperties gameProperties,
IMeshManager meshManager,
IMaterialManager materialManager,
ITextureManager textureManager,
IRenderManager renderManager,
CameraManager cameraManager,
LightStore lightStore,
ILightManager lightManager,
TimeManager timeManager)
{
this.gameContext = gameContext;
this.gameProperties = gameProperties;
this.meshManager = meshManager;
this.textureManager = textureManager;
this.renderManager = renderManager;
this.cameraManager = cameraManager;
this.lightStore = lightStore;
this.lightManager = lightManager;
this.timeManager = timeManager;
skySphereMesh = meshManager.CreateMesh(ObjParser.LoadObj("meshes/skysphere.obj").MeshData);
skyMaterial = materialManager.CreateMaterial("data/skybox.json");
noiseTexture = textureManager.LoadTexture("textures/noise_512.png");
skyMaterial.SetTexture("cloudsTex", noiseTexture);
}
public MaterialListViewModel(IMessageBoxService messageBoxService, IUIVisualizerService uiVisualizerService,
IMaterialManager materialManager, IMaterialGroupManager materialGroupManager, IUnitManager unitManager) : base(messageBoxService, uiVisualizerService, materialManager)
{
// do initialization
try
{
if (materialGroupManager == null)
{
throw new ArgumentNullException("materialGroupManager");
}
_materialGroupManager = materialGroupManager;
if (unitManager == null)
{
throw new ArgumentNullException("unitManager");
}
_unitManager = unitManager;
this.DisplayName = "Material List";
}
catch (Exception ex)
{
this.MessageBoxService.ShowError(this.GetType().FullName + System.Reflection.MethodBase.GetCurrentMethod().Name + ": " + ex.Message);
}
}
public TagsManagerMainView(ITagsManager tagsManager, TagsManagerMainViewModel model,
IIdeaManager ideaManager, IRelationManager relationManager, IBlockManager blockManager, IMaterialManager materialManager)
{
_relationManager = relationManager;
_blockManager = blockManager;
var db = new AllDb()
{
RelationManager = _relationManager,
IdeaManager = ideaManager,
BlockManager = _blockManager,
TagsManager = tagsManager,
MaterialManager = materialManager
};
InitializeComponent();
_tagHelper = new TagTreeHelper(treeList, db);
_tagHelper.ReloadTree();
model.NodeAdded += dto =>
{
dto.AddNodeToTree(treeList);
treeList.CurrentItem = dto;
};
model.NodeAnnihilated += dto => dto.AnnihilateNode(treeList);
model.MaterialUpdate += dto => dto.UpdateMaterialInTree(treeList);
Loaded += (sender, args) =>
{
DataContext = model;
treeList.View.ValidateCell += (o, e) =>
{
var wrong = Path.GetInvalidFileNameChars();
if (e.Value.ToString().Any(wrong.Contains))
e.IsValid = false;
};
treeList.View.PreviewKeyDown += (o, eventArgs) =>
{
if (eventArgs.Key == Key.Enter || eventArgs.Key == Key.Return)
{
eventArgs.Handled = true;
treeList.View.CloseEditor();
RenameCurrent();
}
};
treeList.View.ShownEditor += ViewOnShownEditor;
model.RenameTag += dto => Dispatcher.Invoke(() =>
{
treeList.View.AllowEditing = true;
treeList.View.ShowEditor(true);
}, DispatcherPriority.Background);
model.Refresh += () => Dispatcher.Invoke(() => _tagHelper.ReloadTree(),
DispatcherPriority.Background);
};
}
protected void InitManagers()
{
GeometryManager = new GeometryManager();
MaterialManager = new MaterialManager();
Scope.SetVariable("GeometryManager", GeometryManager);
Scope.SetVariable("MaterialManager", MaterialManager);
}
private static async Task GetMaterialAsync()
{
const string MATERIAL_CODE = "1DACTV76A201000002";
IMaterialManager manager = ServiceProvider.GetRequiredService <IMaterialManager>();
Material result = await manager.GetMaterialWithSubTableAsync(MATERIAL_CODE);
manager.Print(result);
}
public TagSelectorView(ITagsManager tagsManager, IIdeaManager ideaManager,
IBlockManager blockManager, IRelationManager relationManager, ISettingsService settingsService, IMaterialManager materialManager)
{
_settingsService = settingsService;
var allDb = new AllDb
{
RelationManager = relationManager,
BlockManager = blockManager,
IdeaManager = ideaManager,
TagsManager = tagsManager,
MaterialManager = materialManager
};
InitializeComponent();
Loaded += (sender, args) =>
{
var model = RegionContext.GetObservableContext(this).Value as ISelectTagRegionView;
if (model != null)
{
var selectItem = new DelegateCommand<Guid>(id =>
{
if (model.TargetType == typeof(Tag))
_settingsService.AddRecentTag(id);
if (model.TargetType == typeof(Idea))
_settingsService.AddRecentIdea(id);
if (model.TargetType == typeof(Block))
_settingsService.AddRecentBlock(id);
if (model.TargetType == typeof(Comment))
_settingsService.AddRecentComment(id);
if (model.TargetType == typeof(Guidable))
_settingsService.AddRecentGuidable(id);
model.OkCommand.Execute(id);
});
var items = model.TargetType == typeof (Tag)
? _settingsService.GetRecentTags()
: model.TargetType == typeof (Idea)
? _settingsService.GetRecentIdeas()
: model.TargetType == typeof (Block)
? _settingsService.GetRecentBlocks()
: model.TargetType == typeof (Guidable)
? _settingsService.GetRecentGuidables()
: _settingsService.GetRecentComments();
var recent = new BarSubItem() {CategoryName = "BuiltInMenus", Content = "Recent"};
MainMenu.Items.Add(recent);
foreach (var item in items.OrderByDescending(i => i.Order))
recent.Items.Add(new BarButtonItem{Content = item.Name,
CommandParameter = item.Id, Command = selectItem});
}
DataContext = model;
};
_tagHelper = new TagTreeHelper(treeList, allDb);
_tagHelper.ReloadTree();
}
private static async Task GetMaterialsByPrefixWithSubTablesAsync()
{
const string MATERIAL_PREFIX = "11AKPAK";
const int RECORD_COUNT = 10;
IMaterialManager manager = ServiceProvider.GetRequiredService <IMaterialManager>();
List <Material> result = await manager.GetMaterialsByPrefixWithSubTablesAsync(MATERIAL_PREFIX, RECORD_COUNT);
manager.Print(result);
}
public SceneData(BimStore3DModel store, IMaterialManager materialManager)
{
Meshes = new List <MeshData>();
GeometrySources = new List <GeometrySourceData>();
ConstructiveMeshes = new List <ConstructiveMeshData>();
MaterialSources = new List <MaterialSourceData>();
//Materials and Textures
var uniqueTextures = new Dictionary <Guid, TextureSourceData>();
foreach (var material in materialManager.Materials)
{
MaterialSources.Add(new MaterialSourceData(material.Value));
//Get textures
var propertyInfos = material.Value.GetType().GetProperties();
foreach (var propertyInfo in propertyInfos)
{
var attributes = propertyInfo.GetCustomAttributes(typeof(VisualizerTextureMaterialParameter), true);
if (attributes.Length > 0)
{
var texture = (TextureModelEx)propertyInfo.GetValue(material.Value);
if (texture != null)
{
if (!uniqueTextures.ContainsKey(texture.Id))
{
uniqueTextures.Add(texture.Id, new TextureSourceData(texture));
}
}
}
}
}
TextureSources = uniqueTextures.Values.ToList();
//Meshes + Geometries + ConstructiveMeshes
foreach (var item in store.Items)
{
foreach (var geometry in item.Geometries)
{
var meshData = new MeshData(geometry);
Meshes.Add(meshData);
GeometrySources.Add(new GeometrySourceData(meshData, @"GeometrySources"));
ConstructiveMeshes.Add(new ConstructiveMeshData(geometry, meshData.Id, geometry.Material.Id));
}
}
}
public TextModel(IEventAggregator eventAggregator, IMaterialManager materialManager, Guid materialId,
IBlockManager blockManager, IParticlesManager particlesManager, TextEditor textEditor,
IUnityContainer container, ISettingsService settingsService)
{
_eventAggregator = eventAggregator;
_materialManager = materialManager;
_materialId = materialId;
_blockManager = blockManager;
_particlesManager = particlesManager;
_textEditor = textEditor;
_container = container;
_settingsService = settingsService;
Contstruct();
LoadToEditor();
}
public ConspEditorMainViewModel(IIdeaManager ideaManager, IMaterialManager materialManager,
ITagsManager tagsManager, IParticlesManager particlesManager, IBlockManager blockManager,
IEventAggregator eventAggregator, IRelationManager relationManager, ICommentManager commentManager)
{
_ideaManager = ideaManager;
_materialManager = materialManager;
_tagsManager = tagsManager;
_particlesManager = particlesManager;
_blockManager = blockManager;
_eventAggregator = eventAggregator;
_relationManager = relationManager;
_commentManager = commentManager;
Bookmarks = new List<string>();
_eventAggregator.GetEvent<MaterialUpdatedEvent>().Subscribe(MaterialUpdated);
}
public async Task <IActionResult> GetMaterial()
{
try
{
const string MATERIAL_CODE = "1DACTV76A201000002";
IMaterialManager manager = _serviceProvider.GetRequiredService <IMaterialManager>();
Material result = await manager.GetMaterialWithSubTableAsync(MATERIAL_CODE);
return(View(result));
}
catch (Exception e)
{
_logger.LogError(e, "GetMaterial Execution Error");
throw;
}
}
public ConspEditorFastMainView(IMaterialManager materialManager,
IParticlesManager particlesManager, IEventAggregator eventAggregator, ConspEditorFastMainViewModel model, IBlockManager blockManager, IUnityContainer container, ISettingsService settingsService)
{
_materialManager = materialManager;
_particlesManager = particlesManager;
_eventAggregator = eventAggregator;
_blockManager = blockManager;
_container = container;
_settingsService = settingsService;
InitializeComponent();
DataContext = model;
textEditor.VerticalScrollBarVisibility = ScrollBarVisibility.Visible;
textEditor.Options.InheritWordWrapIndentation = false;
_eventAggregator.GetEvent<MaterialUpdatedEvent>().Subscribe(MaterialUpdated);
CreateMenu();
}
public async Task <IActionResult> GetMaterialsByPrefixWithSubTables()
{
try
{
const string MATERIAL_PREFIX = "11AKPAK";
const int RECORD_COUNT = 10;
IMaterialManager manager = _serviceProvider.GetRequiredService <IMaterialManager>();
List <Material> result = await manager.GetMaterialsByPrefixWithSubTablesAsync(MATERIAL_PREFIX, RECORD_COUNT);
return(View(result));
}
catch (Exception e)
{
_logger.LogError(e, "GetMaterialsByPrefixWithSubTables Execution Error");
throw;
}
}
public ExportService(IDbInteropService dbInteropService, IMaterialManager materialManager , IDbImportService dbImportService, ISettingsService settingsService)
{
_dbInteropService = dbInteropService;
_materialManager = materialManager;
_dbImportService = dbImportService;
_settingsService = settingsService;
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Idea, IdeaDto>();
cfg.CreateMap<Comment, CommentDto>();
cfg.CreateMap<Particle, ParticleDto>();
cfg.CreateMap<Relation, RelationDto>();
cfg.CreateMap<Tag, TagDto>();
cfg.CreateMap<Reference, ReferenceDto>();
cfg.CreateMap<Setting, SettingDto>();
cfg.CreateMap<Header, HeaderDto>();
});
_map = config.CreateMapper();
}
public AreaTriggerManager(IGameContext gameContext,
IGameProperties gameProperties,
IMeshManager meshManager,
IMaterialManager materialManager,
AreaTriggerStore areaTriggerStore,
IRenderManager renderManager,
IUIManager uiManager,
CameraManager cameraManager)
{
this.gameContext = gameContext;
this.gameProperties = gameProperties;
this.meshManager = meshManager;
this.areaTriggerStore = areaTriggerStore;
this.renderManager = renderManager;
this.uiManager = uiManager;
this.cameraManager = cameraManager;
boxMesh = meshManager.CreateMesh(ObjParser.LoadObj("meshes/box.obj").MeshData);
sphereMesh = meshManager.CreateMesh(ObjParser.LoadObj("meshes/sphere.obj").MeshData);
wireframe = materialManager.CreateMaterial("data/wireframe.json");
wireframe.SetUniform("Width", 1);
wireframe.SetUniform("Color", Vector4.One);
wireframe.ZWrite = false;
wireframe.DepthTesting = DepthCompare.Lequal;
wireframeBehind = materialManager.CreateMaterial("data/wireframe.json");
wireframeBehind.SetUniform("Width", 0.5f);
wireframeBehind.SetUniform("Color", new Vector4(1, 1, 1, 0.1f));
wireframeBehind.ZWrite = false;
wireframeBehind.DepthTesting = DepthCompare.Greater;
wireframeBehind.BlendingEnabled = true;
wireframeBehind.SourceBlending = Blending.SrcAlpha;
wireframeBehind.DestinationBlending = Blending.OneMinusSrcAlpha;
transcluentMaterial = materialManager.CreateMaterial("data/gizmo.json");
transcluentMaterial.BlendingEnabled = true;
transcluentMaterial.SourceBlending = Blending.SrcAlpha;
transcluentMaterial.DestinationBlending = Blending.OneMinusSrcAlpha;
transcluentMaterial.DepthTesting = DepthCompare.Lequal;
transcluentMaterial.ZWrite = false;
transcluentMaterial.SetUniform("objectColor", new Vector4(0.2f, 0.4f, 1f, 0.3f));
}
public ProductViewModel(IMessageBoxService messageBoxService, Product item, IProductManager manager, IProductGroupManager groupManager, IUnitManager unitManager) : base(messageBoxService, item, manager)
{
// do initialization
try
{
if (groupManager == null)
{
throw new ArgumentNullException("groupManager");
}
_groupManager = groupManager;
// populate the list of groups
this.GroupList = _groupManager.GetList();
if (unitManager == null)
{
throw new ArgumentNullException("unitManager");
}
_unitManager = unitManager;
// populate the list of units
this.UnitList = _unitManager.GetList();
_materialGroupManager = new MaterialGroupManager();
this.MaterialGroupList = _materialGroupManager.GetList();
_materialManager = new MaterialManager();
this.AvailableMaterialList = _materialManager.GetList();
// initialize command
this.SelectMaterialCommand = new CommandBase <Material>(o => this.ExecuteSelectMaterialCommand(o), o => this.CanExecuteSelectItemCommand(o));
this.AddRecipeItemCommand = new CommandBase <Material>(o => this.ExecuteAddRecipeItemCommand(o), o => this.CanExecuteAddRecipeItemCommand(o));
this.RemoveRecipeItemCommand = new CommandBase <RecipeItem>(o => this.ExecuteRemoveRecipeItemCommand(o), o => this.CanExecuteRemoveRecipeItemCommand(o));
this.MarkDeletedCommand = new CommandBase <RecipeItem>(o => this.Item.Delete(), o => !this.Item.IsDeleted);
this.DisplayName = "Edit Product: " + this.Item.Name;
}
catch (Exception ex)
{
this.MessageBoxService.ShowError(this.GetType().FullName + System.Reflection.MethodBase.GetCurrentMethod().Name + ": " + ex.Message);
}
}
public TagsManagerMainViewModel(ITagsManager tagsManager, IBlockManager blockManager,
EventAggregator eventAggregator, IReferenceManager referenceManager, IRelationManager relationManager,
IIdeaManager ideaManager, ISharedService shared, IMaterialManager materialManager, IParticlesManager particlesManager)
{
_eventAggregator = eventAggregator;
_shared = shared;
_db = new AllDb()
{
TagsManager = tagsManager,
RelationManager = relationManager,
IdeaManager = ideaManager,
BlockManager = blockManager,
MaterialManager = materialManager,
ParticlesManager = particlesManager
};
_eventAggregator.GetEvent<BlockAddedEvent>().Subscribe(guid =>
{
var block = _db.BlockManager.GetBlockById(guid);
if (block is Idea)
{
var ideaDto = IdeaDto.FromBase(block as Idea, _db);
OnNodeAdded(ideaDto);
}
if (block is Relation)
{
var relDto = RelationDto.FromBase(block as Relation, _db);
OnNodeAdded(relDto);
}
if (block is Comment)
{
var commDto = CommentDto.FromBase(block as Comment, _db);
OnNodeAdded(commDto);
}
});
_eventAggregator.GetEvent<DatabaseImportedEvent>().Subscribe(s => OnRefresh());
_eventAggregator.GetEvent<MaterialUpdatedEvent>().Subscribe(guid =>
{
var mat = _db.MaterialManager.GetMaterialById(guid);
var matDto = MaterialDto.FromBase(mat, _db);
OnMaterialUpdate(matDto as MaterialDto);
});
NewTagCommand = new DelegateCommand<TreeItemDto>((dto) =>
{
if (dto == null || dto is TagDto)
{
var added = _db.TagsManager.AddTag(dto == null ? null : (Guid?) dto.Id, "New tag");
var addedDto = TagDto.FromBase(added, _db);
OnNodeAdded(addedDto);
OnRenameTag(addedDto);
}
});
NewIdeaCommand = new DelegateCommand<TreeItemDto>(dto =>
{
/*var added = _ideaManager.CreateIdea("New idea");
var addedDto = _map.Map<IdeaDto>(added);
OnNodeAdded(addedDto);
OnRenameTag(addedDto);*/
});
AddReferenceCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto || dto is RelationDto)
{
var dlgVm = new CreateReferenceDlgViewModel(_db.BlockManager, dto);
if (shared.SelectedParticle != Guid.Empty)
{
var pis = _db.ParticlesManager.GetParticleInplacesForParticle(shared.SelectedParticle);
if (pis != null && pis.Any())
{
var block = _db.BlockManager.GetBlockById(pis.First().BlockId) as Idea;
if (block != null)
dlgVm.Block2 = new NamedGuid() {Caption = block.Caption, Uid = block.Id};
}
}
var dlg = new CreateReferenceDlg(dlgVm);
var res = dlg.ShowDialog();
if (res.HasValue && res.Value)
{
if (dlgVm.IsTo || dlgVm.IsBoth)
{
var refer = referenceManager.CreateReference(dlgVm.Block1.Uid, dlgVm.Block2.Uid);
OnNodeAdded(ReferenceDto.FromBase(refer, _db));
}
if (dlgVm.IsFrom || dlgVm.IsBoth)
{
var refer = referenceManager.CreateReference(dlgVm.Block2.Uid, dlgVm.Block1.Uid);
OnNodeAdded(ReferenceDto.FromBase(refer, _db));
}
}
}
});
ClearCommand = new DelegateCommand(() =>
{
tagsManager.DeleteAllTAgs();
OnRefresh();
});
OpenIdeaCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto)
Interfaces.CompositeCommands.OpenBlockCommand.Execute(dto.Id);
if (dto is MaterialDto)
Interfaces.CompositeCommands.OpenSourceCommand.Execute(dto.Id);
});
RenameCommand = new DelegateCommand<TreeItemDto>(OnRenameTag);
AddCurrentMaterialCommand = new DelegateCommand<TagDto>(dto =>
{
if (_shared.CurrentMaterial.HasValue)
{
_db.TagsManager.ApplyTagToMaterial(_shared.CurrentMaterial.Value, dto.Id);
var m = _db.MaterialManager.GetMaterialById(_shared.CurrentMaterial.Value);
var addedDto = MaterialDto.FromBase(m, _db);
OnNodeAdded(addedDto);
}
});
DeleteCommand = new DelegateCommand<TreeItemDto>(dto =>
{
if (dto is IdeaDto)
{
_db.IdeaManager.DeleteIdea((dto as IdeaDto).Id);
NodeAnnihilated(dto);
}
});
}
public BmdFixedFunctionMaterial(
IMaterialManager materialManager,
int materialEntryIndex,
BMD bmd,
IList <BmdTexture> tex1Textures)
{
// TODO: materialEntry.Flag determines draw order
var materialEntry = bmd.MAT3.MaterialEntries[materialEntryIndex];
var materialName = bmd.MAT3.MaterialNameTable[materialEntryIndex];
var populatedMaterial = bmd.MAT3.PopulatedMaterials[materialEntryIndex];
var textures =
populatedMaterial.TextureIndices
.Select(i => i != -1 ? tex1Textures[i] : null)
.ToArray();
var material = materialManager.AddFixedFunctionMaterial();
material.Name = materialName;
material.CullingMode =
bmd.MAT3.CullModes[materialEntry.CullModeIndex] switch {
BMD.CullMode.None => CullingMode.SHOW_BOTH,
BMD.CullMode.Front => CullingMode.SHOW_BACK_ONLY,
BMD.CullMode.Back => CullingMode.SHOW_FRONT_ONLY,
BMD.CullMode.All => CullingMode.SHOW_NEITHER,
_ => throw new ArgumentOutOfRangeException(),
};
material.SetBlending(
ConvertBmdBlendModeToFin(populatedMaterial.BlendMode.BlendMode),
ConvertBmdBlendFactorToFin(populatedMaterial.BlendMode.SrcFactor),
ConvertBmdBlendFactorToFin(populatedMaterial.BlendMode.DstFactor),
ConvertBmdLogicOpToFin(populatedMaterial.BlendMode.LogicOp));
material.SetAlphaCompare(
ConvertBmdAlphaOpToFin(populatedMaterial.AlphaCompare.MergeFunc),
ConvertBmdAlphaCompareTypeToFin(populatedMaterial.AlphaCompare.Func0),
populatedMaterial.AlphaCompare.Reference0 / 255f,
ConvertBmdAlphaCompareTypeToFin(populatedMaterial.AlphaCompare.Func1),
populatedMaterial.AlphaCompare.Reference1 / 255f);
this.Material = material;
var colorConstants = new List <Color>();
// TODO: Need to use material entry indices
var equations = material.Equations;
var colorZero = equations.CreateColorConstant(0);
var scZero = equations.CreateScalarConstant(0);
var scOne = equations.CreateScalarConstant(1);
var scTwo = equations.CreateScalarConstant(2);
var scFour = equations.CreateScalarConstant(4);
var scHalf = equations.CreateScalarConstant(.5);
var scMinusHalf = equations.CreateScalarConstant(-.5);
var colorFixedFunctionOps = new ColorFixedFunctionOps(equations);
var scalarFixedFunctionOps = new ScalarFixedFunctionOps(equations);
var valueManager = new ValueManager(equations);
// TODO: Where are color constants set inside the materials?
// TODO: Need to support registers
// TODO: Need to support multiple vertex colors
// TODO: Colors should just be RGB in the fixed function library
// TODO: Seems like only texture 1 is used, is this accurate?
// TODO: This might need to be TevKonstColorIndexes
valueManager.SetColorRegisters(
materialEntry.TevColorIndexes.Take(4)
.Select(
tevColorIndex => bmd.MAT3.ColorS10[tevColorIndex])
.ToArray());
var konstColors =
materialEntry.TevKonstColorIndexes
.Take(4)
.Select(konstIndex => bmd.MAT3.Color3[konstIndex])
.ToArray();
valueManager.SetKonstColors(konstColors);
for (var i = 0; i < materialEntry.TevStageInfoIndexes.Length; ++i)
{
var tevStageIndex = materialEntry.TevStageInfoIndexes[i];
if (tevStageIndex == -1)
{
continue;
}
var tevStage = bmd.MAT3.TevStages[tevStageIndex];
var tevOrderIndex = materialEntry.TevOrderInfoIndexes[i];
var tevOrder = bmd.MAT3.TevOrders[tevOrderIndex];
// Updates which texture is referred to by TEXC
var textureIndex = tevOrder.TexMap;
if (textureIndex == -1)
{
valueManager.UpdateTextureColor(null);
}
else
{
var bmdTexture = textures[textureIndex];
// TODO: Share texture definitions between materials?
var texture = materialManager.CreateTexture(bmdTexture.Image);
texture.Name = bmdTexture.Name;
texture.WrapModeU = bmdTexture.WrapModeS;
texture.WrapModeV = bmdTexture.WrapModeT;
texture.ColorType = bmdTexture.ColorType;
var texCoordGen =
bmd.MAT3.TexCoordGens[
materialEntry.TexGenInfo[tevOrder.TexCoordId]];
var texGenSrc = texCoordGen.TexGenSrc;
switch (texGenSrc)
{
case >= GxTexGenSrc.Tex0 and <= GxTexGenSrc.Tex7: {
var texCoordIndex = texGenSrc - GxTexGenSrc.Tex0;
texture.UvIndex = texCoordIndex;
break;
}
case GxTexGenSrc.Normal: {
texture.UvType = UvType.LINEAR;
break;
}
default: {
//Asserts.Fail($"Unsupported texGenSrc type: {texGenSrc}");
texture.UvIndex = 0;
break;
}
}
valueManager.UpdateTextureColor(textureIndex);
material.SetTextureSource(textureIndex, texture);
}
// Updates which color is referred to by RASC
var colorChannel = tevOrder.ColorChannelId;
valueManager.UpdateRascColor(colorChannel);
// Updates which values are referred to by konst
valueManager.UpdateKonst(materialEntry.KonstColorSel[tevOrderIndex],
materialEntry.KonstAlphaSel[tevOrderIndex]);
// Set up color logic
{
var colorA = valueManager.GetColor(tevStage.color_a);
var colorB = valueManager.GetColor(tevStage.color_b);
var colorC = valueManager.GetColor(tevStage.color_c);
var colorD = valueManager.GetColor(tevStage.color_d);
IColorValue?colorValue = null;
// TODO: Switch this to an enum
var colorOp = tevStage.color_op;
switch (colorOp)
{
// ADD: out = a*(1 - c) + b*c + d
case TevOp.GX_TEV_ADD:
case TevOp.GX_TEV_SUB: {
var bias = tevStage.color_bias switch {
TevBias.GX_TB_ZERO => null,
TevBias.GX_TB_ADDHALF => scHalf,
TevBias.GX_TB_SUBHALF => scMinusHalf,
_ => throw new ArgumentOutOfRangeException(
"Unsupported color bias!")
};
var scale = tevStage.color_scale switch {
TevScale.GX_CS_SCALE_1 => scOne,
TevScale.GX_CS_SCALE_2 => scTwo,
TevScale.GX_CS_SCALE_4 => scFour,
TevScale.GX_CS_DIVIDE_2 => scHalf,
_ => throw new ArgumentOutOfRangeException(
"Unsupported color scale!")
};
colorValue =
colorFixedFunctionOps.AddOrSubtractOp(
colorOp == TevOp.GX_TEV_ADD,
colorA,
colorB,
colorC,
colorD,
bias,
scale
);
colorValue ??= colorZero;
colorValue.Clamp = tevStage.color_clamp;
break;
}
default: {
if (BmdFixedFunctionMaterial.STRICT)
{
throw new NotImplementedException();
}
else
{
colorValue = colorC;
}
break;
}
}
valueManager.UpdateColorRegister(tevStage.color_regid, colorValue);
var colorAText =
new FixedFunctionEquationsPrettyPrinter <FixedFunctionSource>()
.Print(colorA);
var colorBText =
new FixedFunctionEquationsPrettyPrinter <FixedFunctionSource>()
.Print(colorB);
var colorCText =
new FixedFunctionEquationsPrettyPrinter <FixedFunctionSource>()
.Print(colorC);
var colorDText =
new FixedFunctionEquationsPrettyPrinter <FixedFunctionSource>()
.Print(colorD);
var colorValueText =
new FixedFunctionEquationsPrettyPrinter <FixedFunctionSource>()
.Print(colorValue);
;
}
// Set up alpha logic
{
var alphaA = valueManager.GetAlpha(tevStage.alpha_a);
var alphaB = valueManager.GetAlpha(tevStage.alpha_b);
var alphaC = valueManager.GetAlpha(tevStage.alpha_c);
var alphaD = valueManager.GetAlpha(tevStage.alpha_d);
IScalarValue?alphaValue = null;
// TODO: Switch this to an enum
var alphaOp = tevStage.alpha_op;
switch (alphaOp)
{
// ADD: out = a*(1 - c) + b*c + d
case TevOp.GX_TEV_ADD:
case TevOp.GX_TEV_SUB: {
var bias = tevStage.alpha_bias switch {
TevBias.GX_TB_ZERO => null,
TevBias.GX_TB_ADDHALF => scHalf,
TevBias.GX_TB_SUBHALF => scMinusHalf,
_ => throw new ArgumentOutOfRangeException(
"Unsupported alpha bias!")
};
var scale = tevStage.alpha_scale switch {
TevScale.GX_CS_SCALE_1 => scOne,
TevScale.GX_CS_SCALE_2 => scTwo,
TevScale.GX_CS_SCALE_4 => scFour,
TevScale.GX_CS_DIVIDE_2 => scHalf,
_ => throw new ArgumentOutOfRangeException(
"Unsupported alpha scale!")
};
alphaValue =
scalarFixedFunctionOps.AddOrSubtractOp(
alphaOp == TevOp.GX_TEV_ADD,
alphaA,
alphaB,
alphaC,
alphaD,
bias,
scale
);
alphaValue ??= scZero;
//alphaValue.Clamp = tevStage.alpha_clamp;
break;
}
default: {
if (BmdFixedFunctionMaterial.STRICT)
{
throw new NotImplementedException();
}
else
{
alphaValue = scZero;
}
break;
}
}
valueManager.UpdateAlphaRegister(tevStage.alpha_regid, alphaValue);
var alphaAText =
new FixedFunctionEquationsPrettyPrinter <FixedFunctionSource>()
.Print(alphaA);
var alphaBText =
new FixedFunctionEquationsPrettyPrinter <FixedFunctionSource>()
.Print(alphaB);
var alphaCText =
new FixedFunctionEquationsPrettyPrinter <FixedFunctionSource>()
.Print(alphaC);
var alphaDText =
new FixedFunctionEquationsPrettyPrinter <FixedFunctionSource>()
.Print(alphaD);
var alphaValueText =
new FixedFunctionEquationsPrettyPrinter <FixedFunctionSource>()
.Print(alphaValue);
;
}
}
equations.CreateColorOutput(
FixedFunctionSource.OUTPUT_COLOR,
valueManager.GetColor(GxCc.GX_CC_CPREV));
equations.CreateScalarOutput(
FixedFunctionSource.OUTPUT_ALPHA,
valueManager.GetAlpha(GxCa.GX_CA_APREV));
// TODO: Set up compiled texture
// TODO: If only a const color, create a texture for that
var sb = new StringBuilder();
{
using var os = new StringWriter(sb);
// TODO: Print textures, colors
new FixedFunctionEquationsPrettyPrinter <FixedFunctionSource>()
.Print(os, equations);
}
var output = sb.ToString();
var colorTextureCount =
material.Textures.Count(
texture => texture.ColorType == ColorType.COLOR);
// TODO: This is a bad assumption!
if (colorTextureCount == 0 && colorConstants.Count > 0)
{
var colorConstant = colorConstants.Last();
var intensityTexture = material.Textures
.FirstOrDefault(
texture => texture.ColorType ==
ColorType.INTENSITY);
if (intensityTexture != null)
{
return;
}
var colorImage = FinImage.Create1x1WithColor(colorConstant);
var colorTexture = materialManager.CreateTexture(colorImage);
material.CompiledTexture = colorTexture;
}
}
public ImportManagerModel(Action <int, object> reportProgress, IMaterialManager materialManager)
{
this.reportProgress = reportProgress;
MaterialManager = materialManager;
}
public BimStoreItem3DViewModel(BimStoreItem3DModel model, IMaterialManager materialManager)
{
Model = model;
Geometries = new ObservableCollection <BimGeometry3DViewModel>(model.Geometries.Select(x => new BimGeometry3DViewModel(x)));
}
public BimStore3DViewModel(BimStore3DModel model, IMaterialManager materialManager)
{
Model = model;
Items = new ObservableCollection <BimStoreItem3DViewModel>(model.Items.Select(item => new BimStoreItem3DViewModel(item, materialManager)));
}
public SourcesManagerMainViewModel(IMaterialManager materialManager, IEventAggregator eventAggregator)
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Material, MaterialDto>()
.ForMember(dest => dest.Parent, opts =>
opts.MapFrom(s => s.Parent != null ? s.Parent.Id : (Guid?) null));
});
_map = config.CreateMapper();
_materialManager = materialManager;
_eventAggregator = eventAggregator;
UpdateFromBase();
_eventAggregator.GetEvent<DatabaseImportedEvent>().Subscribe(s => UpdateFromBase());
ImportFileCommand = new DelegateCommand<MaterialDto>(item =>
{
if (item != null && !item.IsFolder)
return;
var dlgModel = new AddFileDlgViewModel() {Material = new MaterialDto()
{
IsFolder = false,
Parent = item != null ? item.Id : (Guid?) null
}};
var dlg = new AddFileDlg(dlgModel);
var res = dlg.ShowDialog();
if (res.HasValue && res.Value)
{
var material = _materialManager.ImportNewFile(dlgModel.Material.Name,
dlgModel.Material.Author, dlgModel.Material.Source, dlgModel.Material.Parent, dlgModel.Path);
UpdateFromBase();
CurrentItem = Materials.FirstOrDefault(m => m.Id == material);
}
});
NewFileCommand = new DelegateCommand<MaterialDto>(item =>
{
if (item != null && !item.IsFolder)
return;
var dlgModel = new NewFileDlgViewModel()
{
Material = new MaterialDto()
{
IsFolder = false,
Parent = item != null ? item.Id : (Guid?)null
}
};
var dlg = new NewFileDlg(dlgModel);
var res = dlg.ShowDialog();
if (res.HasValue && res.Value)
{
var material = _materialManager.CreateNewFile(dlgModel.Material.Name,
dlgModel.Material.Author, dlgModel.Material.Source, dlgModel.Material.Parent);
UpdateFromBase();
CurrentItem = Materials.FirstOrDefault(m => m.Id == material);
}
});
NewFolderCommand = new DelegateCommand<MaterialDto>(o =>
{
var added = _materialManager.AddFolder(o == null ? null : (Guid?)o.Id, "New folder");
UpdateFromBase();
CurrentItem = Materials.FirstOrDefault(m => m.Id == added);
OnRenameFolder();
});
RenameCommand = new DelegateCommand(OnRenameFolder);
OpenMaterialCommand = new DelegateCommand<MaterialDto>(item =>
{
if (item != null && !item.IsFolder)
Interfaces.CompositeCommands.OpenSourceCommand.Execute(item.Id);
});
DeleteCommand = new DelegateCommand<MaterialDto>(item =>
{
var btnMessageBox = MessageBoxButton.YesNoCancel;
var icnMessageBox = MessageBoxImage.Warning;
MessageBoxResult rsltMessageBox =
MessageBox.Show(String.Format("Вы действительно хотите удалить {0}", item.Name), "Удалить материал",
btnMessageBox, icnMessageBox);
if (rsltMessageBox == MessageBoxResult.Yes)
{
_materialManager.DeleteMaterial(item.Id);
UpdateFromBase();
}
});
}
public VisualizerManagerModel(IMaterialManager materialManager)
{
this.materialManager = materialManager;
}
public MaterialDispatcherWindow(IMaterialManager materialManager, IView3DManager view3DManager)
{
InitializeComponent();
Manager.Initialize(materialManager, view3DManager);
}
