public FormModelAdd()
{
InitializeComponent();
_bc = new BrandController();
_mc = new ModelController();
}
private void Start()
{
Instance = this;
FindObjectOfType <AssetBundlesManager>().InstantiateModels();
}
public AttributeDialog(PSMAttribute attribute, IControlsPSMAttributes psmClassController, ModelController controller)
: this(attribute, controller)
{
this.psmClassController = psmClassController;
if (attribute.RepresentedAttribute != null) //pimless attribute
{
foreach (Control control in psmDisabled)
{
control.IsEnabled = false;
}
foreach (UIElement control in psmHidden)
{
control.Visibility = Visibility.Collapsed;
}
}
tbAlias.Text = attribute.Alias;
}
protected virtual void Awake()
{
// Get components
chatdoll = gameObject.GetComponent <Chatdoll>();
modelController = gameObject.GetComponent <ModelController>();
voiceRequestProvider = gameObject.GetComponent <VoiceRequestProviderBase>();
cameraRequestProvider = gameObject.GetComponent <CameraRequestProvider>();
qrcodeRequestProvider = gameObject.GetComponent <QRCodeRequestProvider>();
wakeWordListener = GetComponent <WakeWordListenerBase>();
// Prompt
var httpPrompter = gameObject.GetComponent <HttpPrompter>();
if (httpPrompter != null)
{
chatdoll.OnPromptAsync = httpPrompter.OnPromptAsync;
}
else
{
if (!string.IsNullOrEmpty(PromptVoice))
{
if (PromptVoiceType == VoiceSource.Local)
{
PromptAnimatedVoiceRequest.AddVoice(PromptVoice);
}
else if (PromptVoiceType == VoiceSource.Web)
{
PromptAnimatedVoiceRequest.AddVoiceWeb(PromptVoice);
}
else if (PromptVoiceType == VoiceSource.TTS)
{
PromptAnimatedVoiceRequest.AddVoiceTTS(PromptVoice);
}
}
if (!string.IsNullOrEmpty(PromptFace))
{
PromptAnimatedVoiceRequest.AddFace(PromptFace);
}
if (!string.IsNullOrEmpty(PromptAnimation))
{
PromptAnimatedVoiceRequest.AddAnimation(PromptAnimation);
}
chatdoll.OnPromptAsync = async(r, u, c, t) =>
{
await modelController.AnimatedSay(PromptAnimatedVoiceRequest, t);
};
}
// Error
chatdoll.OnErrorAsync = async(r, c, t) =>
{
await modelController.AnimatedSay(ErrorAnimatedVoiceRequest, t);
};
// Wakeword Listener
if (wakeWordListener != null)
{
// Register wakeword
if (wakeWordListener.WakeWords.Count == 0)
{
if (!string.IsNullOrEmpty(WakeWord))
{
wakeWordListener.WakeWords.Add(new WakeWord()
{
Text = WakeWord, Intent = string.Empty
});
}
}
// Register cancel word
if (wakeWordListener.CancelWords.Count == 0)
{
if (!string.IsNullOrEmpty(CancelWord))
{
wakeWordListener.CancelWords.Add(CancelWord);
}
}
// Awaken
wakeWordListener.OnWakeAsync = async(wakeword) =>
{
var skipPrompt = false;
Request preRequest = null;
// Set request type, intent and inline request if set
if (wakeword.RequestType != RequestType.None ||
!string.IsNullOrEmpty(wakeword.Intent) ||
!string.IsNullOrEmpty(wakeword.InlineRequestText))
{
preRequest = new Request(wakeword.RequestType);
preRequest.Intent = wakeword.Intent;
if (!string.IsNullOrEmpty(wakeword.InlineRequestText))
{
preRequest.Text = wakeword.InlineRequestText;
skipPrompt = true;
}
}
// Invoke chat
await chatdoll.StartChatAsync(GetUserId(), skipPrompt, preRequest);
};
// Cancel
wakeWordListener.OnCancelAsync = async() => { chatdoll.StopChat(); };
// Raise voice detection threshold when chatting
wakeWordListener.ShouldRaiseThreshold = () => { return(chatdoll.IsChatting); };
}
// Voice Request Provider
if (voiceRequestProvider != null)
{
// Set message window
if (voiceRequestProvider.MessageWindow == null)
{
InstantiateMessageWindos();
voiceRequestProvider.MessageWindow = MessageWindow;
}
// Register cancel word to request provider
if (voiceRequestProvider.CancelWords.Count == 0)
{
voiceRequestProvider.CancelWords.Add(CancelWord);
}
}
// Camera and QRCode Request Provider
if (cameraRequestProvider.ChatdollCamera == null)
{
InstantiateCamera();
cameraRequestProvider.ChatdollCamera = ChatdollCamera;
}
if (qrcodeRequestProvider.ChatdollCamera == null)
{
InstantiateCamera();
qrcodeRequestProvider.ChatdollCamera = ChatdollCamera;
}
}
protected virtual void Awake()
{
modelController = gameObject.GetComponent <ModelController>();
}
public ModelController_Test() : base()
{
_testTarget = new ModelController(_mockService.Object);
}
/// <summary>
/// Creates new instance of <see cref="AlterSimpleTypeCommand">AlterSimpleTypeCommand</see>.
/// </summary>
/// <param name="modelController">command controller</param>
public AlterSimpleTypeCommand(ModelController modelController)
: base(modelController)
{
Description = CommandDescription.PSM_COMPONENT_REORDER;
}
/// <summary>
/// Creates new instance of ChangeElementMultiplicityCommand
/// <param name="modelController">Associated model controller</param>
/// </summary>
public override IStackedCommand Create(ModelController modelController)
{
return(new ChangeElementMultiplicityCommand(modelController));
}
public void RenderModel(ModelController modelController)
{
Model model = modelController.TargetModel;
Matrix[] transforms = modelController.Bones;
if (transforms == null)
{
transforms = new Matrix[model.Bones.Count];
modelController.Bones = transforms;
}
model.CopyAbsoluteBoneTransformsTo(transforms);
// Draw the model. A model can have multiple meshes, so loop.
foreach (ModelMesh mesh in model.Meshes)
{
// This is where the mesh orientation is set, as well as our camera and projection.
foreach (BasicEffect effect in mesh.Effects)
{
effect.EnableDefaultLighting();
effect.World = transforms[mesh.ParentBone.Index] * modelController.Transform;
// * Matrix.CreateRotationY(modelRotation)
//* Matrix.CreateTranslation(modelPosition);
effect.View = GameController.CurrentGame.Camera.View;
effect.Projection = GameController.CurrentGame.Camera.PerspectiveMatrix;
}
// Draw the mesh, using the effects set above.
mesh.Draw();
}
}
public virtual ActionResult Create()
{
ModelController <m> list = GetController() as ModelController <m>;
return(View());
}
public ChangeElementMultiplicityCommand(ModelController controller)
: base(controller)
{
Description = CommandDescription.CHANGE_MULTIPLICITY;
}
public ModelControllerTest()
{
// this.MessageBus = new KosmographMessageBus();
this.modelController = new ModelController(this.NewModel());
}
public void UpdateInformation()
{
int MappingID = Convert.ToInt32(Request.QueryString["Code"].ToString());
ModelUI objUI = new ModelUI();
ModelController objController = new ModelController();
int flag = CheckMaterial();
if (flag == 0)
{
objUI.Material = txtMaterial.Text.Trim();
objUI.GroupID = Convert.ToInt32(drpModel.SelectedValue);
objUI.ModelCategoryID = Convert.ToInt32(drpCategory.SelectedValue);
if (chkSpecial.Checked)
{
objUI.ModelSpecialID = Convert.ToInt32(drpSpecial.SelectedValue);
}
else
{
objUI.ModelSpecialID = 0;
}
objUI.ClutchTypeID = Convert.ToInt32(drpClutch.SelectedValue);
objUI.Description = txtDescription.Text.Trim();
objUI.MappingID = MappingID;
try
{
MappingID = objController.UpdateModelDetail(objUI, null);
if (MappingID > 0)
{
Response.Redirect("ModelDefaultNew.aspx");
}
else
{
string str = "<script language = 'javascript'>";
str += "setMessageText('ctl00_ContentPlaceHolder1_lblMessage','Records could not ne updated successfully');";
str += "</script>";
literal1.Text = str;
}
}
catch
{
string str = "<script language = 'javascript'>";
str += "setMessageText('ctl00_ContentPlaceHolder1_lblMessage','Records could not ne updated successfully');";
str += "</script>";
literal1.Text = str;
}
}
else
{
string str = "<script language = 'javascript'>";
str += "setMessageText('ctl00_ContentPlaceHolder1_lblMessage','Material already exists');";
str += "</script>";
literal1.Text = str;
}
}
public int CheckMaterial()
{
int Flag = 0;
ModelUI objUI = new ModelUI();
objUI.Material = txtMaterial.Text.Trim();
ModelController objController = new ModelController();
Flag = objController.CheckMaterial(objUI, null);
return Flag;
}
public NewPSMAssociationCommand(ModelController modelController)
: base(modelController)
{
Description = CommandDescription.ADD_PSM_ASSOCIATION;
}
private void inputControl(string key)
{
switch (key)
{
case "faster":
if (SimulationSpeed < 1000)
{
SimulationSpeed = SimulationSpeed * 2;
}
ViewController.setSpeedText("X" + SimulationSpeed);
break;
case "slower":
if (SimulationSpeed > 0.1)
{
SimulationSpeed = SimulationSpeed * 0.5;
}
ViewController.setSpeedText("X" + SimulationSpeed);
break;
case "pause":
IsPaused = !IsPaused;
break;
case "back":
ModelController.mapBackFiveSeconds();
break;
case "toggleDebugMode":
debugMode = !debugMode;
break;
case "add1":
ModelController.newAstroids(1);
break;
case "add2":
ModelController.newAstroids(2);
break;
case "add3":
ModelController.newAstroids(3);
break;
case "switchCollision":
if (_collisionDetection.GetType() == typeof(QuadTreeCollision))
{
_collisionDetection = new NaiveCollision();
}
else
{
_collisionDetection = new QuadTreeCollision();
}
break;
case "switchPathing":
if (_pathing.GetType() == typeof(DijkstraSearch))
{
_pathing = new BFSearch();
}
else
{
_pathing = new DijkstraSearch();
}
break;
case "remove1":
ModelController.removeAstroids(1);
break;
case "remove2":
ModelController.removeAstroids(2);
break;
case "remove3":
ModelController.removeAstroids(3);
break;
default:
break;
}
}
/// <summary>
/// Creates new instance of RemoveAssociationEndCommmand
/// <param name="modelController">Associated model controller</param>
/// </summary>
public override IStackedCommand Create(ModelController modelController)
{
return(new RemoveAssociationEndCommmand(modelController));
}
public async void gameLoop()
{
DateTime oldTick = DateTime.UtcNow;
DateTime newTick = DateTime.UtcNow;
SimulationParams simulationParams = new SimulationParams(new TimeSpan(), new TimeSpan());
GalaxyBuilder galaxyBuilder = new GalaxyBuilder();
_collisionDetection = new QuadTreeCollision();
_pathing = new BFSearch();
IsPaused = false;
while (true)
{
var file = ViewController.hasFile();
if (file?.Length > 0)
{
Map Galaxy = galaxyBuilder.buildGalaxy(loadGalaxy(file));
ModelController = new ModelController(Galaxy);
simulationParams.TotalTime = TimeSpan.Zero;
ContainsGalaxy = true;
SimulationSpeed = 2;
file = null;
ViewController.resetFile();
ViewController.setSpeedText("X" + SimulationSpeed);
}
//simulationLoop
while (ContainsGalaxy && ViewController.MainView.File == null)
{
newTick = DateTime.UtcNow;
//TODO: check public and private everywhere (blijft hier tot dpa deadline
//unit testing is 15% van het punt, voeg ze voor dpa toe
//TODO: gebruik reflection factory voor behaviours
inputControl(ViewController.getKeyPressed());
simulationParams.SetDelta(newTick - oldTick, SimulationSpeed);
ModelController.runGameTick(simulationParams);
//collision related code
ModelController.CurMap.celestialBodies = _collisionDetection.Collide(ModelController.CurMap.celestialBodies);
if (debugMode) //this should only be enabled for the algorithm assignment, but it is a cool showcase of the program
{
ViewController.bounds = _collisionDetection.GetBounds();
List <CelestialBody> sortedList = ModelController.CurMap.celestialBodies
.OrderByDescending(x => x.Radius).ToList()
.Where(n => n.Name != null).ToList();
ModelController.CurMap.celestialBodies = _pathing
.GetPath(
ModelController.CurMap.celestialBodies,
sortedList[0],
sortedList[1]
);
}
else
{
ViewController.bounds = null;
ModelController.CurMap.celestialBodies.All(cb => { cb.IsMarked = false; return(true); });
}
ViewController.drawFrame(ModelController.CurMap.celestialBodies);
if (DateTime.UtcNow - newTick < MinTickTime)
{
await Task.Delay(MinTickTime);
}
oldTick = newTick;
while (IsPaused && ViewController.MainView.File == null) //pause loop
{
await Task.Delay(MinTickTime);
inputControl(ViewController.getKeyPressed());
oldTick = DateTime.UtcNow;
}
}
await Task.Delay(MinTickTime);
}
}
/// <summary>
/// Creates new instance of AlterSimpleTypeCommand
/// <param name="modelController">Associated diagram controller</param>
/// </summary>
public override IStackedCommand Create(ModelController modelController)
{
return(new AlterSimpleTypeCommand(modelController));
}
/// <summary>
/// Creates new instance of <see cref="ChangeOntologyEquivalentCommand" />.
/// </summary>
/// <param name="controller">command controller</param>
public ChangeOntologyEquivalentCommand(ModelController controller)
: base(controller)
{
}
void Start()
{
//初始化model
model = GameObject.FindGameObjectWithTag("Model").GetComponent <ModelController>();
}
/// <summary>
/// Creates new instance of ChangeOntologyEquivalentCommand
/// <param name="modelController">Associated model controller</param>
/// </summary>
public override IStackedCommand Create(ModelController modelController)
{
return(new ChangeOntologyEquivalentCommand(modelController));
}
public User(ModelController mc)
{
_mc = mc;
}
private void Awake()
{
modelController = modelContext.ModelController;
}
protected override void Awake()
{
base.Awake();
modelController = modelContext.ModelController;
backListener = viewContext.BackButtonListener;
}
/// <summary>
/// Creates new instance of DeleteFromModelCommand
/// <param name="modelController">Associated model controller</param>
/// </summary>
public override IStackedCommand Create(ModelController modelController)
{
return(new DeleteFromModelCommand(modelController));
}
public AttributeDialog(Property attribute, IControlsAttributes pimClassController, ModelController controller)
: this(attribute, controller)
{
this.pimClassController = pimClassController;
foreach (UIElement element in psmOnly)
{
element.Visibility = Visibility.Collapsed;
}
tbOnto.Text = attribute.OntologyEquivalent;
}
public DeleteFromModelCommand(ModelController Controller)
: base(Controller)
{
Description = CommandDescription.DELETE_FROM_MODEL;
}
public RemovePSMSuperordinateComponentCommand(ModelController modelController)
: base(modelController)
{
Description = CommandDescription.REMOVE_PSM_SUPERORDINATE;
}
/// <summary>
/// Creates new instance of DerivePSMClassToNewDiagramCommand
/// <param name="modelController">Associated diagram controller</param>
/// </summary>
public override IStackedCommand Create(ModelController modelController)
{
return(new DerivePSMClassToNewDiagramCommand(modelController));
}
/// <summary>
/// Creates new instance of NewPSMAssociationCommand
/// <param name="modelController">Associated model controller</param>
/// </summary>
public override IStackedCommand Create(ModelController modelController)
{
return(new NewPSMAssociationCommand(modelController));
}
private IEnumerable <IdleStatus> finishInitialization(String defaultModel)
{
yield return(IdleStatus.Ok);
splashScreen.updateStatus(15, "Loading Resources");
VirtualFileSystem.Instance.addArchive(OgreModelEditorConfig.VFSRoot);
emptyResourceManager = pluginManager.createScratchResourceManager();
liveResourceManager = pluginManager.createLiveResourceManager("Scene");
resourceManager = pluginManager.createScratchResourceManager();
yield return(IdleStatus.Ok);
splashScreen.updateStatus(40, "Creating GUI");
//Initialize controllers
modelController = new ModelController(this);
//Create the GUI
consoleWindow = new LogWindow();
guiManager.addManagedDialog(consoleWindow);
consoleWindow.Visible = true;
Log.Default.addLogListener(consoleWindow);
virtualTextureDebugger = new VirtualTextureDebugger(virtualTextureLink.VirtualTextureManager);
guiManager.addManagedDialog(virtualTextureDebugger);
textureCompiler = new TextureCompilerGUI(pluginManager, mainWindow);
textureCompiler.CurrentSrc = OgreModelEditorConfig.LastTextureCompilerSourceDirectory;
guiManager.addManagedDialog(textureCompiler);
materialEditor = new MDIObjectEditor("Materials", "MaterialEditor", false);
guiManager.addManagedDialog(materialEditor);
materialEditor.CurrentDockLocation = DockLocation.Left;
materialEditor.Visible = true;
materialEditor.EditInterface = materialController.EditInterface;
yield return(IdleStatus.Ok);
splashScreen.updateStatus(70, "Creating Scene");
//Create a simple scene to use to show the models
SimSceneDefinition sceneDefiniton = new SimSceneDefinition();
OgreSceneManagerDefinition ogreScene = new OgreSceneManagerDefinition("Ogre");
SimSubSceneDefinition mainSubScene = new SimSubSceneDefinition("Main");
sceneDefiniton.addSimElementManagerDefinition(ogreScene);
sceneDefiniton.addSimSubSceneDefinition(mainSubScene);
mainSubScene.addBinding(ogreScene);
sceneDefiniton.DefaultSubScene = "Main";
scene = sceneDefiniton.createScene();
sceneViewController.createCameras(scene);
lightManager.sceneLoaded(scene);
objectMover.sceneLoaded(scene);
virtualTextureLink.sceneLoaded(scene);
yield return(IdleStatus.Ok);
if (!String.IsNullOrEmpty(defaultModel))
{
splashScreen.updateStatus(80, "Loading Model");
openModel(defaultModel);
yield return(IdleStatus.Ok);
}
splashScreen.updateStatus(100, "Loaded");
splashScreen.hide();
yield return(IdleStatus.Ok);
}
/// <summary>
/// Creates new instance of RenameElementCommand
/// <param name="modelController">Associated model controller</param>
/// </summary>
public override IStackedCommand Create(ModelController modelController)
{
return(new RenameElementCommand <ElementType>(modelController));
}
public MainWindow(ModelController model)
: base(Gtk.WindowType.Toplevel)
{
Build ();
this.model = model;
}
