private SceneObject GetCatesianGridObj(CatesianGrid grid, List <GridBlockProperty> gridProperties, string fileName)
{
CatesianGridRenderer renderer = CatesianGridRenderer.Create(
-grid.DataSource.Position, grid, this.scientificCanvas.ColorPalette.Sampler);
//string caseFileName = System.IO.Path.GetFileName(fileName);
renderer.WorldPosition = -grid.DataSource.Position;
renderer.Initialize();
SceneObject gridObj = renderer.WrapToSceneObject(
new ModelScaleScript(),
new DumpCatesianGridTreeNodeScript());
{
BoundingBoxRenderer boxRenderer = renderer.GetBoundingBoxRenderer();
SceneObject boxObj = boxRenderer.WrapToSceneObject(
new ModelScaleScript());
gridObj.Children.Add(boxObj);
}
foreach (var gbp in gridProperties)
{
var script = new ScientificModelScript(gridObj, gbp, this.scientificCanvas.ColorPalette);
gridObj.Scripts.Add(script);
}
return(gridObj);
}
private void FormMain_Load(object sender, EventArgs e)
{
//this.scientificCanvas.Scene.RootObject.Children.ItemAdded += RootObject.Children_ItemAdded;
//this.scientificCanvas.Scene.RootObject.Children.ItemRemoved += RootObject.Children_ItemRemoved;
{
SceneObject groundObj = SceneObjectFactory.GetBuildInSceneObject(BuildInSceneObject.Ground);
{
BoundingBoxRenderer boxRenderer = groundObj.Renderer.GetBoundingBoxRenderer();
SceneObject boxObj = boxRenderer.WrapToSceneObject(new ModelScaleScript());
groundObj.Children.Add(boxObj);
}
this.scientificCanvas.Scene.RootObject.Children.Add(groundObj);
//TreeNode groundTreeNode = this.objectsTreeView.Nodes.Add(groundObj.Name);
//groundTreeNode.Tag = groundObj;
TreeNode groundTreeNode = DumpTreeNode(groundObj);
this.objectsTreeView.Nodes.Add(groundTreeNode);
}
{
SceneObject axisObj = SceneObjectFactory.GetBuildInSceneObject(BuildInSceneObject.Axis);
{
BoundingBoxRenderer boxRenderer = axisObj.Renderer.GetBoundingBoxRenderer();
SceneObject boxObj = boxRenderer.WrapToSceneObject(new ModelScaleScript());
axisObj.Children.Add(boxObj);
}
this.scientificCanvas.Scene.RootObject.Children.Add(axisObj);
//TreeNode axisTreeNode = this.objectsTreeView.Nodes.Add(axisObj.Name);
//axisTreeNode.Tag = axisObj;
TreeNode axisTreeNode = DumpTreeNode(axisObj);
this.objectsTreeView.Nodes.Add(axisTreeNode);
this.objectsTreeView.ExpandAll();
}
Application.Idle += Application_Idle;
}
private SceneObject[] GetWellObjects(SimulationInputData inputData, CatesianGrid grid, string fileName)
{
var result = new List <SceneObject>();
List <CSharpGL.Tuple <WellRenderer, LabelRenderer> > wellList = this.CreateWellList(inputData, grid);
if (wellList == null)
{
return(result.ToArray());
}
//this.AddWellNodes(gridderNode, this.scene, well3dList);
foreach (var item in wellList)
{
item.Item1.Initialize();
SceneObject wellObj = item.Item1.WrapToSceneObject(new ModelScaleScript());
{
BoundingBoxRenderer boxRenderer = item.Item1.GetBoundingBoxRenderer();
SceneObject boxObj = boxRenderer.WrapToSceneObject(new ModelScaleScript());
wellObj.Children.Add(boxObj);
}
result.Add(wellObj);
{
SceneObject labelObj = item.Item2.WrapToSceneObject(
new ModelScaleScript(),
new LabelTargetScript(item.Item1));
wellObj.Children.Add(labelObj);
}
}
return(result.ToArray());
}
public void ShowBoundingRect(bool show = true)
{
if (show)
{
BoundingBoxRenderer.UpdateRectangle();
}
BoundingBoxRenderer.enabled = show;
}
public override void UnloadContent()
{
base.UnloadContent();
Picker.UnloadContent();
Picker = null;
RenderWindow = null;
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
SpriteBatch = null;
SelectedNode = null;
UnSelectedNode = null;
Picker = null;
}
public static void Render(Camera camera, Matrix4 projection)
{
if (_blockRaytrace == null)
{
return;
}
BoundingBoxRenderer.Render(_blockRaytrace.BoundingBox, _blockRaytrace.BlockPos.ToVector3(), 1.01f, camera,
projection);
}
public BoundedRenderer(GridViewRenderer renderer, vec3 lengths)
{
if (renderer == null)
{
throw new ArgumentNullException();
}
this.BoxRenderer = BoundingBoxRenderer.Create(lengths);
this.Renderer = renderer;
}
public override void LoadContent()
{
base.LoadContent();
if (!string.IsNullOrEmpty(AttachedPathingNodeName) && AttachedPathingNode == null)
AttachedPathingNode = GameScreen.GetPath(AttachedPathingNodeName);
// Check to see if this was pre-loaded
if (string.IsNullOrEmpty(SpriteSheetFileName))
{
Actor original;
if (ContentManager != null)
original = ContentManager.Load<Actor>(AssetName);
else
original = GameScreen.Content.Load<Actor>(AssetName);
if (original == null)
throw new Exception("Error: Could not load the Actor!");
Direction = original.Direction;
DrawOrder = original.DrawOrder;
UpdateOrder = original.UpdateOrder;
Name = original.Name;
PlayerIndex = original.PlayerIndex;
Role = original.Role;
Enabled = original.Enabled;
Visible = original.Visible;
SpriteSheetFileName = original.SpriteSheetFileName;
ClipPlayer = new AnimationPlayer2D(Game)
{
AssetName = original.ClipPlayer.AssetName,
Sequences = original.ClipPlayer.Sequences
};
}
ClipPlayer.GameScreen = GameScreen;
ClipPlayer.SetShaderParameters += OnSetShaderParams;
ClipPlayer.AssetPath = AssetFolder;
ClipPlayer.AssetName = SpriteSheetFileName;
ClipPlayer.Game = Game;
ClipPlayer.GameScreen = GameScreen;
ClipPlayer.SpriteBatch = SpriteBatch;
ClipPlayer.ContentManager = ContentManager;
ClipPlayer.Initialize();
if (BoundingBoxRenderer == null)
{
BoundingBoxRenderer = new BoundingBoxRenderer(Game);
BoundingBoxRenderer.GameScreen = GameScreen;
BoundingBoxRenderer.SpriteBatch = SpriteBatch;
BoundingBoxRenderer.Initialize();
}
}
private void Form_Load(object sender, EventArgs e)
{
{
var camera = new Camera(
new vec3(5, 3, 4), new vec3(0, 0, 0), new vec3(0, 1, 0),
CameraType.Perspecitive, this.glCanvas1.Width, this.glCanvas1.Height);
var scene = new Scene(camera, this.glCanvas1);
scene.ClearColor = Color.SkyBlue;
this.glCanvas1.Resize += scene.Resize;
this.scene = scene;
var cameraManipulater = new SatelliteManipulater();
cameraManipulater.Bind(camera, this.glCanvas1);
this.cameraManipulater = cameraManipulater;
}
{
const int gridsPer2Unit = 20;
const int scale = 2;
GroundRenderer renderer = GroundRenderer.Create(new GroundModel(gridsPer2Unit * scale));
renderer.Scale = new vec3(scale, scale, scale);
SceneObject obj = renderer.WrapToSceneObject(generateBoundingBox: true);
this.scene.RootObject.Children.Add(obj);
}
{
var arcballManipulater = new ArcBallManipulater();
arcballManipulater.Bind(this.scene.Camera, this.glCanvas1);
SimpleRenderer renderer = SimpleRenderer.Create(new Teapot());
SceneObject obj = renderer.WrapToSceneObject();
obj.Scripts.Add(new ArcballScript(arcballManipulater));
{
BoundingBoxRenderer box = renderer.GetBoundingBoxRenderer();
var boxObj = box.WrapToSceneObject();
boxObj.Scripts.Add(new ArcballScript(arcballManipulater));
obj.Children.Add(boxObj);
}
this.scene.RootObject.Children.Add(obj);
}
{
var uiAxis = new UIAxis(AnchorStyles.Left | AnchorStyles.Bottom,
new Padding(3, 3, 3, 3), new Size(128, 128));
uiAxis.Initialize();
this.scene.UIRoot.Children.Add(uiAxis);
}
{
var builder = new StringBuilder();
builder.AppendLine("1: Scene's property grid.");
builder.AppendLine("2: Canvas' property grid.");
builder.AppendLine("3: Form's property grid.");
MessageBox.Show(builder.ToString());
}
{
this.scene.Start();
}
}
public override void LoadContent()
{
if (RenderWindow == null)
{
RenderWindow = Globals.RenderWindow;
}
Picker = new BoundingBoxRenderer(Game);
Picker.Initialize();
base.LoadContent();
}
/// <summary>
/// Draws ingame chunk debugger.
/// </summary>
/// <param name="graphicsDevice"></param>
/// <param name="camera"></param>
/// <param name="spriteBatch"></param>
/// <param name="spriteFont"></param>
public void DrawInGameDebugVisual(GraphicsDevice graphicsDevice, ICamera camera, SpriteBatch spriteBatch, SpriteFont spriteFont)
{
var position = RelativePosition + " " + this.ChunkState;
var positionSize = spriteFont.MeasureString(position);
var projected = graphicsDevice.Viewport.Project(Vector3.Zero, camera.Projection, camera.View,
Matrix.CreateTranslation(new Vector3(WorldPosition.X + WidthInBlocks / 2, HighestSolidBlockOffset - 1, WorldPosition.Z + LengthInBlocks / 2)));
spriteBatch.DrawString(spriteFont, position, new Vector2(projected.X - positionSize.X / 2, projected.Y - positionSize.Y / 2), Color.Yellow);
BoundingBoxRenderer.Render(this.BoundingBox, graphicsDevice, camera.View, camera.Projection, Color.DarkRed);
}
public void Set(SceneObject sceneObject)
{
SceneObject = sceneObject;
_boundingBoxRenderer = sceneObject.GetComponent <BoundingBoxRenderer>();
if (_boundingBoxRenderer == null)
{
_boundingBoxRenderer = sceneObject.AddComponent <BoundingBoxRenderer>();
}
_renderer = sceneObject.GetComponent <Renderer>();
}
public void Set(GameObject gameObject)
{
GameObject = gameObject;
_boudingBoxRenderer = gameObject.GetComponent <BoundingBoxRenderer>();
if (_boudingBoxRenderer == null)
{
_boudingBoxRenderer = gameObject.AddComponent <BoundingBoxRenderer>();
}
_renderer = gameObject.GetComponent <Renderer>();
}
public override void LoadContent()
{
CustomEffect = GameScreen.Content.Load <Effect>("SpriteShader");
if (BoundingBoxRenderer == null)
{
BoundingBoxRenderer = new BoundingBoxRenderer(Game);
BoundingBoxRenderer.SpriteBatch = SpriteBatch;
BoundingBoxRenderer.Initialize();
}
base.LoadContent();
}
public override void Initialize()
{
base.Initialize();
Picker = new BoundingBoxRenderer(Game);
Picker.Initialize();
SelectedNode = Utilitys.GenerateTexture(GraphicsDevice, Color.White, 10, 10);
UnSelectedNode = Utilitys.GenerateTexture(GraphicsDevice, Color.Orange, 10, 10);
// Init our sprite batch
SpriteBatch = new SpriteBatch(GraphicsDevice);
}
public override void Initialize()
{
if (BoundingBoxRenderer == null)
{
BoundingBoxRenderer = new BoundingBoxRenderer(Game);
BoundingBoxRenderer.GameScreen = GameScreen;
BoundingBoxRenderer.SpriteBatch = SpriteBatch;
BoundingBoxRenderer.Initialize();
}
base.Initialize();
}
public GuiResourceLoading(GameWindow window)
{
CommonResources.Load();
PluginManager.AddPlugin(new FileSystemRaw(new DirectoryInfo("Plugins\\System")));
ResourceReader.ClearCache();
ClientResources.Load(window);
BoundingBoxRenderer.Load();
_background = ResourceReader.ReadTexture("System/Textures/Gui/ResourceLoadingBackground.png");
_progressBar = ResourceReader.ReadTexture("System/Textures/Gui/Progressbar.png");
_progressBarFull = ResourceReader.ReadTexture("System/Textures/Gui/ProgressbarFull.png");
Start(false);
}
public void Select(bool isSelected)
{
if (GameObject != null)
{
_boudingBoxRenderer.Enabled = isSelected;
if (!isSelected)
{
_renderer = null;
_boudingBoxRenderer = null;
GameObject = null;
}
}
}
private bool UpdateCurrentNode(TreeNode node)
{
bool updated = false;
var stack = new Stack <TreeNode>();
stack.Push(node);
BoundingBoxRenderer selectedRenderer = null;
while (stack.Count > 0)
{
TreeNode current = stack.Pop();
var obj = current.Tag as SceneObject;
if (obj != null)
{
var renderer = obj.Renderer as BoundingBoxRenderer;
if (renderer != null)
{
selectedRenderer = renderer;
break;
}
}
foreach (TreeNode item in current.Nodes)
{
stack.Push(item);
}
}
if (selectedRenderer != lastselectedBoxRenderer)
{
if (selectedRenderer != null)
{
selectedRenderer.BoundingBoxColor = Color.Aqua;
var glState = selectedRenderer.StateList.Find(x => x is LineWidthState) as LineWidthState;
glState.LineWidth = 3;
}
if (lastselectedBoxRenderer != null)
{
lastselectedBoxRenderer.BoundingBoxColor = Color.White;
var glState = lastselectedBoxRenderer.StateList.Find(x => x is LineWidthState) as LineWidthState;
glState.LineWidth = 1;
}
this.lastselectedBoxRenderer = selectedRenderer;
updated = true;
}
return(updated);
}
public override void UnloadContent()
{
base.UnloadContent();
if (Picker != null)
{
Picker.UnloadContent();
Picker = null;
}
foreach (var v in Objects)
{
v.UnloadContent();
}
}
public override void UnloadContent()
{
base.UnloadContent();
SpriteBatch = null;
SelectedNode = null;
UnSelectedNode = null;
if (Picker != null)
{
Picker.UnloadContent();
Picker = null;
}
}
private BoundingBoxRenderer GetBoundingBoxRenderer(params IRectangle3D[] rectangles)
{
Rectangle3D rect = rectangles[0].GetRectangle();
for (int i = 1; i < rectangles.Length; i++)
{
rect = rect.Union(rectangles[i].GetRectangle());
}
vec3 lengths = rect.Max - rect.Min;
vec3 originalWorldPosition = rect.Max / 2 + rect.Min / 2;
BoundingBoxRenderer boxRenderer = BoundingBoxRenderer.Create(lengths, originalWorldPosition);
boxRenderer.SwitchList.Add(new LineWidthSwitch(1));
return(boxRenderer);
}
public override void Init()
{
base.Init();
_selectionRenderer = _drawAreaSelectionRenderer;
_downLeftAnchor = Program.Instance.DownLeft;
_upRightAnchor = Program.Instance.UpRight;
_downLeftAnchor += new Vector2(10, 10);
_upRightAnchor -= new Vector2(10, 10);
_drawAreaRenderer.UpdateRenderer(DownLeftAnchor, UpRightAnchor, true);
_drawAreaSelectionRenderer.UpdateRenderer(DownLeftAnchor, UpRightAnchor, false);
_borderRenderer.UpdateRenderer(DownLeftAnchor, UpRightAnchor, false);
SetPoints();
BoundingBoxRenderer.UpdateRectangle();
}
public MainPage()
{
this.InitializeComponent();
// Initialize helper class used to render the skill results on screen
m_bboxRenderer = new BoundingBoxRenderer(UIOverlayCanvas);
m_processedBitmapSource = new SoftwareBitmapSource();
PopulateCommands();
ApiContainer.Register <ComputerVisionService>(new ComputerVisionService());
this.dispatcher = new UIDispatcher(SynchronizationContext.Current);
this.notifier = new UINotifier();
this.ViewModel = this.CreateMainViewModel(this.dispatcher, this.notifier);
this.DataContext = this.ViewModel;
this.ViewModel.ControllerViewModel.PropertyChanged += this.ControllerViewModel_PropertyChanged;
isListening = false;
}
public void Update(GameTime gTime)
{
if (!End && Lambda < MaxLambda)
{
Lambda += 0.1f;
World = Matrix.CreateScale(0.055f) * Matrix.CreateTranslation(new Vector3(0, 0, -Lambda)) * Matrix.Invert(View);
Position = World.Translation;
BoundingBox = BoundingBoxRenderer.UpdateBoundingBox(Model, World);
if (Lambda < MaxLambda)
{
Actions[CurrentAction].Invoke();
}
else
{
End = true;
}
}
}
public override void Initialize()
{
base.Initialize();
Particles = new List <Particle>(MaxParticles);
freeParticles = new Queue <Particle>(MaxParticles);
for (int i = 0; i < MinParticles; i++)
{
Particle part = new Particle();
part.Color = ParticleColor;
part.Texture = Texture;
// first, call PickRandomDirection to figure out which way the particle
// will be moving. velocity and acceleration's values will come from this.
Vector2 direction = Utilitys.PickRandomDirection();
// pick some random values for our particle
float velocity = Utilitys.RandomBetween(MinInitialSpeed, MaxInitialSpeed);
float acceleration = Utilitys.RandomBetween(MinAcceleration, MaxAcceleration);
float lifeSpan = Utilitys.RandomBetween(MinLifeSpan, MaxLifeSpan);
float scale = Utilitys.RandomBetween(MinScale, MaxScale);
float rotationSpeed = Utilitys.RandomBetween(MinRotationSpeed, MaxRotationSpeed);
// then initialize it with those random values. initialize will save those,
// and make sure it is marked as active.
part.Initialize(Position, velocity * direction, acceleration * direction, lifeSpan, scale, rotationSpeed);
// Enqueue it in our free particles queue
freeParticles.Enqueue(part);
// Load it to our particles collection
Particles.Add(part);
if (OnParticleSpawningEvent != null)
{
OnParticleSpawningEvent.Invoke(part);
}
}
// Debug Bounding Box Renderer
BoundingBoxRenderer = new BoundingBoxRenderer(Game);
BoundingBoxRenderer.Initialize();
}
public override void LoadContent()
{
base.LoadContent();
IsCentered = true;
if (Picker == null)
{
Picker = new BoundingBoxRenderer(Game);
Picker.Initialize();
}
if (BoundingBoxRenderer == null)
{
BoundingBoxRenderer = new BoundingBoxRenderer(Game);
BoundingBoxRenderer.SpriteBatch = SpriteBatch;
BoundingBoxRenderer.Initialize();
}
}
public override void LoadContent()
{
CustomEffect = GameScreen.Content.Load <Effect>("SpriteShader");
if (Texture == null)
{
Texture = Utilitys.TextureFromFile(Globals.Game.GraphicsDevice, Globals.GetDestinationTexturePath(AssetName));
}
BoundingBoxRenderer = new BoundingBoxRenderer(Game);
BoundingBoxRenderer.Initialize();
if (AttachedPathingNode != null)
{
AttachedPathingNode.Initialize();
}
base.LoadContent();
}
public override void Clone(ScalableObject toClone, Vector2 positioner)
{
base.Init();
_selectionRenderer = _drawAreaSelectionRenderer;
AreaObject areaObjectToClone = toClone as AreaObject;
_downLeftAnchor = areaObjectToClone.DownLeftAnchor;
_upRightAnchor = areaObjectToClone.UpRightAnchor;
_drawAreaRenderer.UpdateRenderer(DownLeftAnchor, UpRightAnchor, true);
_drawAreaSelectionRenderer.UpdateRenderer(DownLeftAnchor, UpRightAnchor, false);
_borderRenderer.UpdateRenderer(DownLeftAnchor, UpRightAnchor, false);
SetPoints();
BoundingBoxRenderer.UpdateRectangle();
PositionAtCenter(positioner);
Hover(false);
ShowBoundingRect(false);
selected = false;
}
public ObjectShip()
: base("model")
{
UpdateBoundingBox();
bbRenderer = new BoundingBoxRenderer();
}
