public static void Run()
{
// ExStart:Save3DScene
// The path to the documents directory.
string MyDir = RunExamples.GetDataDir();
// Load a 3D document into Aspose.3D
Scene scene = new Scene();
// Open an existing 3D scene
scene.Open(MyDir + "document.fbx");
// Save Scene to a stream
MemoryStream dstStream = new MemoryStream();
scene.Save(dstStream, FileFormat.FBX7500ASCII);
// Rewind the stream position back to zero so it is ready for next reader.
dstStream.Position = 0;
// Save Scene to a local path
scene.Save(MyDir + "output_out.fbx", FileFormat.FBX7500ASCII);
// ExEnd:Save3DScene
Console.WriteLine("\nConverted 3D document to stream successfully.");
}
public MyGraphicsScreen(IGraphicsService graphicsService)
: base(graphicsService)
{
_meshRenderer = new MeshRenderer();
var contentManager = ServiceLocator.Current.GetInstance<ContentManager>();
var spriteFont = contentManager.Load<SpriteFont>("SpriteFont1");
_debugRenderer = new DebugRenderer(graphicsService, spriteFont);
Scene = new Scene();
// Add a camera with a perspective projection.
var projection = new PerspectiveProjection();
projection.SetFieldOfView(
ConstantsF.PiOver4,
graphicsService.GraphicsDevice.Viewport.AspectRatio,
0.1f,
100.0f);
CameraNode = new CameraNode(new Camera(projection))
{
Name = "CameraPerspective",
PoseWorld = Pose.FromMatrix(Matrix44F.CreateLookAt(new Vector3F(10, 5, 10), new Vector3F(0, 1, 0), new Vector3F(0, 1, 0)).Inverse),
};
Scene.Children.Add(CameraNode);
}
private void Form_Load(object sender, EventArgs e)
{
{
var camera = new Camera(
new vec3(0, 0, 5), new vec3(0, 0, 0), new vec3(0, 1, 0),
CameraType.Perspecitive, this.glCanvas1.Width, this.glCanvas1.Height);
var rotator = new SatelliteManipulater();
rotator.Bind(camera, this.glCanvas1);
rotator.BindingMouseButtons = System.Windows.Forms.MouseButtons.Left | System.Windows.Forms.MouseButtons.Right;
this.rotator = rotator;
this.scene = new Scene(camera, this.glCanvas1);
this.glCanvas1.Resize += this.scene.Resize;
}
{
Teapot model = new Teapot();
OrderDependentTransparencyRenderer renderer = OrderDependentTransparencyRenderer.Create(model, model.Size, Teapot.strPosition, Teapot.strColor);
SceneObject obj = renderer.WrapToSceneObject();
this.scene.RootObject.Children.Add(obj);
}
{
var builder = new StringBuilder();
builder.AppendLine("1: Scene's property grid.");
builder.AppendLine("2: Canvas' property grid.");
MessageBox.Show(builder.ToString());
}
}
/// <summary>
/// Recieve Event to change the current level portal's state. This will have a transition cause the player is present.
/// </summary>
/// <param name="scene"></param>
/// <param name="state"></param>
void OnLevelActivate(Scene scene, State state)
{
if (scene == sceneToLoad)
{
switch (state)
{
case State.Undefined:
break;
case State.InActive:
mesh.renderer.material.mainTexture = _defaultTexture;
//gameObject.renderer.material.color = Color.red;
iTween.Stop(gameObject);
isActive = false;
break;
case State.Active:
mesh.renderer.material.mainTexture = _activeTexture;
iTween.ShakePosition(gameObject, iTween.Hash("amount", Vector3.forward/4f, "time", .5f, "looptype", iTween.LoopType.loop));
iTween.ShakeRotation(gameObject, iTween.Hash("z", 5f, "time", .5f, "looptype", iTween.LoopType.loop));
isActive = true;
break;
default:
throw new NotImplementedException();
}
}
}
public static void Run()
{
// Initialize scene object
Scene scene = new Scene();
// Initialize Node class object
Node cubeNode = new Node("cube");
// Call Common class create mesh method to set mesh instance
Mesh mesh = Common.CreateMesh();
// Point node to the Mesh geometry
cubeNode.Entity = mesh;
// Set rotation
cubeNode.Transform.Rotation = Quaternion.FromRotation(new Vector3(0, 1, 0), new Vector3(0.3, 0.5, 0.1));
// Set translation
cubeNode.Transform.Translation = new Vector3(0, 0, 20);
// Add cube to the scene
scene.RootNode.ChildNodes.Add(cubeNode);
// The path to the documents directory.
string MyDir = RunExamples.GetDataDir_GeometryAndHierarchy();
MyDir = MyDir + "TransformationToNode.fbx";
// Save 3D scene in the supported file formats
scene.Save(MyDir, FileFormat.FBX7400ASCII);
Console.WriteLine("\nTransformation added successfully to node.\nFile saved at " + MyDir);
}
public static void Run()
{
// ExStart:AddTransformationToNodeByEulerAngles
// Initialize scene object
Scene scene = new Scene();
// Initialize Node class object
Node cubeNode = new Node("cube");
// Call Common class create mesh using polygon builder method to set mesh instance
Mesh mesh = Common.CreateMeshUsingPolygonBuilder();
// Point node to the Mesh geometry
cubeNode.Entity = mesh;
// Euler angles
cubeNode.Transform.EulerAngles = new Vector3(0.3, 0.1, -0.5);
// Set translation
cubeNode.Transform.Translation = new Vector3(0, 0, 20);
// Add cube to the scene
scene.RootNode.ChildNodes.Add(cubeNode);
// The path to the documents directory.
string MyDir = RunExamples.GetDataDir();
MyDir = MyDir + RunExamples.GetOutputFilePath("TransformationToNode.fbx");
// Save 3D scene in the supported file formats
scene.Save(MyDir, FileFormat.FBX7500ASCII);
// ExEnd:AddTransformationToNodeByEulerAngles
Console.WriteLine("\nTransformation added successfully to node.\nFile saved at " + MyDir);
}
public static void Run()
{
// ExStart:AddAssetInformationToScene
// Initialize a 3D scene
Scene scene = new Scene();
// Set application/tool name
scene.AssetInfo.ApplicationName = "Egypt";
// Set application/tool vendor name
scene.AssetInfo.ApplicationVendor = "Manualdesk";
// We use ancient egyption measurement unit Pole
scene.AssetInfo.UnitName = "pole";
// One Pole equals to 60cm
scene.AssetInfo.UnitScaleFactor = 0.6;
// The path to the documents directory.
string MyDir = RunExamples.GetDataDir();
MyDir = MyDir + RunExamples.GetOutputFilePath("InformationToScene.fbx");
// Save scene to 3D supported file formats
scene.Save(MyDir, FileFormat.FBX7500ASCII);
// ExEnd:AddAssetInformationToScene
Console.WriteLine("\nAsset information added successfully to Scene.\nFile saved at " + MyDir);
}
public static Model FromScene(Scene scene, Device device)
{
VertexDeclaration vertexDeclaration = new VertexDeclaration(device,
VertexPositionNormalTexture.VertexElements);
Model result = new Model(scene, device, vertexDeclaration);
foreach (Mesh mesh in scene.Meshes)
{
VertexBuffer vertexBuffer = new VertexBuffer(device,
mesh.Positions.Count * VertexPositionNormalTexture.SizeInBytes,
Usage.WriteOnly, VertexFormat.None, Pool.Default);
DataStream vertexDataStream = vertexBuffer.Lock(0,
mesh.Positions.Count * VertexPositionNormalTexture.SizeInBytes,
LockFlags.None);
VertexPositionNormalTexture[] vertices = new VertexPositionNormalTexture[mesh.Positions.Count];
for (int i = 0; i < vertices.Length; ++i)
vertices[i] = new VertexPositionNormalTexture(mesh.Positions[i], (mesh.Normals.Count > i) ? mesh.Normals[i] : Vector3D.Zero, Point2D.Zero);
vertexDataStream.WriteRange(vertices);
vertexBuffer.Unlock();
IndexBuffer indexBuffer = new IndexBuffer(device, mesh.Indices.Count * sizeof(int),
Usage.WriteOnly, Pool.Default, false);
DataStream indexDataStream = indexBuffer.Lock(0, mesh.Indices.Count * sizeof(int), LockFlags.None);
indexDataStream.WriteRange(mesh.Indices.ToArray());
indexBuffer.Unlock();
ModelMesh modelMesh = new ModelMesh(mesh, device, vertexBuffer,
mesh.Positions.Count, indexBuffer, mesh.PrimitiveCount,
Matrix3D.Identity, mesh.Material);
result.Meshes.Add(modelMesh);
}
return result;
}
/**
* Invokes all possible checks for the trajectory
* @param scene
*/
public static void fixTrajectory(Scene scene)
{
fixSingleNode(scene);
fixDuplicateNodes(scene);
fixMissingNodes(scene);
fixNodesWithSameLocation(scene);
}
private void Form_Load(object sender, EventArgs e)
{
{
var camera = new Camera(
new vec3(0, 0, 1), new vec3(0, 0, 0), new vec3(0, 1, 0),
CameraType.Perspecitive, this.glCanvas1.Width, this.glCanvas1.Height);
var rotator = new SatelliteRotator(camera);
this.rotator = rotator;
this.scene = new Scene(camera);
}
{
var glText = new UIText(AnchorStyles.Left | AnchorStyles.Top | AnchorStyles.Right,
new Padding(10, 10, 10, 10), new Size(550, 50), -100, 100);
glText.Initialize();
glText.SwitchList.Add(new ClearColorSwitch());// show black back color to indicate glText's area.
glText.SetText("The quick brown fox jumps over the lazy dog!");
this.glText = glText;
this.scene.UIRoot.Children.Add(glText);
var glAxis = new UIAxis(AnchorStyles.Right | AnchorStyles.Bottom,
new Padding(3, 3, 3, 3), new Size(70, 70), -100, 100);
glAxis.Initialize();
this.scene.UIRoot.Children.Add(glAxis);
this.UpdateLabel();
}
{
var frmPropertyGrid = new FormProperyGrid();
frmPropertyGrid.DisplayObject(this.glText);
frmPropertyGrid.Show();
this.formPropertyGrid = frmPropertyGrid;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GameAction" /> class.
/// </summary>
/// <param name="name">Name of the game action.</param>
/// <param name="scene">The scene</param>
protected GameAction(string name, Scene scene = null)
{
this.IsSkippable = true;
this.State = TaskState.None;
this.Name = name;
this.Scene = scene;
}
public PhysXBox( float width, float height, float length, Scene scene )
: base(width, height, length)
{
if (scene == null) throw new ArgumentNullException( "scene" );
this.actor = CreateBoxActor( scene, width, height, length );
}
public SceneComponent(Scene aScene)
{
mScene = aScene;
// Add Events
AddEventListeners();
}
public override void OnAdd(Scene scene)
{
treeMaterials = new List<Material>();
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LeafMat0"));
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LeafMat8"));
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LeafMat2"));
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LeafMat3"));
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LeafMat4"));
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LeafMat5"));
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LeafMat6"));
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LeafMat7"));
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LTreeMat0")); // Tree trunk
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LTreeMat1"));
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LTreeMat2"));
treeMaterials.Add(ResourceManager.Inst.GetMaterial("LTreeMat3"));
Vector3 randPosition = Vector3.Zero;
Vector3 randNormal = Vector3.Zero;
RandomHelper.RandomGen.NextDouble();
scene.MainTerrain.GenerateRandomTransform(RandomHelper.RandomGen, out randPosition, out randNormal);
while (randPosition.Y < 5.0f || Vector3.Dot(randNormal, Vector3.Up) < 0.5f)
{
scene.MainTerrain.GenerateRandomTransform(RandomHelper.RandomGen, out randPosition, out randNormal);
}
generateTree(randPosition);
base.OnAdd(scene);
}
protected override async Task LoadContent()
{
await base.LoadContent();
graphicsCompositor = new SceneGraphicsCompositorLayers
{
Cameras = { Camera.Get<CameraComponent>() },
Master =
{
Renderers =
{
new ClearRenderFrameRenderer { Color = Color.Green, Name = "Clear frame" },
new SceneDelegateRenderer(PreCameraRendererDraw),
new SceneCameraRenderer { Mode = SceneCameraRenderer },
new SceneDelegateRenderer(PostCameraRendererDraw),
}
}
};
Scene = new Scene { Settings = { GraphicsCompositor = graphicsCompositor } };
Scene.AddChild(Camera);
var ambientLight = new Entity { new LightComponent { Type = new LightAmbient { Color = new LightColorRgb(Color.White) }, Intensity = 1 } };
Scene.AddChild(ambientLight);
SceneSystem.SceneInstance = new SceneInstance(Services, Scene);
}
void CustomInitialize()
{
SpriteManager.Camera.UsePixelCoordinates();
SpriteManager.Camera.X = 129;
SpriteManager.Camera.Y = -216;
#if !XNA3
FlatRedBallServices.GraphicsOptions.TextureFilter = Microsoft.Xna.Framework.Graphics.TextureFilter.Point;
#endif
SpriteEditorScene ses = SceneSave.FromFile("Content/Screens/TmxScreen/FinalFantasyScene.scnx".ToLowerInvariant());
scene = new Scene();
ses.SetScene<Sprite>(ContentManagerName, scene, SceneSettingOptions.ConvertZSeparatedSpritesIntoSpriteGrids);
scene.Shift(new Vector3(0, 0, 0));
scene.AddToManagers();
TestLevel2.X -= 530;
if (string.IsNullOrEmpty(TilbTest.MapLayers[0].Name))
{
throw new Exception("Map layers names are not coming through");
}
// Layer 0 should be called "LayerWithStuff"
if (TmxWithEmptyLayers.MapLayers[0].Name != "LayerWithStuff")
{
throw new Exception("Having empty layers can screw up Layer names. " +
"This layer should be named \"LayerWithStuff\" but it is instead named " + TmxWithEmptyLayers.MapLayers[0].Name);
}
TestRotatedTiles();
}
public override Scene OnLoadScene()
{
this.mEngine.RegisterUpdateHandler(new FPSLogger());
Scene scene = new Scene(1);
scene.Background = new ColorBackground(0.09804f, 0.6274f, 0.8784f);
Random random = new Random(RANDOM_SEED);
for (int i = 0; i < LINE_COUNT; i++)
{
float x1 = (float)(random.NextDouble() * CAMERA_WIDTH);
float x2 = (float)(random.NextDouble() * CAMERA_WIDTH);
float y1 = (float)(random.NextDouble() * CAMERA_HEIGHT);
float y2 = (float)(random.NextDouble() * CAMERA_HEIGHT);
float lineWidth = (float)(random.NextDouble() * 5);
Line line = new Line(x1, y1, x2, y2, lineWidth);
line.SetColor((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
scene.getLastChild().attachChild(line);
}
return scene;
}
private void Form_Load(object sender, EventArgs e)
{
{
var camera = new Camera(
new vec3(5, 4, 3) * 4, new vec3(0, 0, 0), new vec3(0, 1, 0),
CameraType.Perspecitive, this.glCanvas1.Width, this.glCanvas1.Height);
var rotator = new SatelliteManipulater();
rotator.Bind(camera, this.glCanvas1);
this.camera = camera;
this.rotator = rotator;
this.scene = new Scene(camera, this.glCanvas1);
this.glCanvas1.Resize += this.scene.Resize;
}
{
var renderer = ConditionalRenderer.Create();
renderer.Initialize();
SceneObject obj = renderer.WrapToSceneObject(name: "Conditional Renderer Demo");
this.scene.RootObject.Children.Add(obj);
this.conditionalRenderer = renderer;
}
//{
// 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("O: to select image.");
builder.AppendLine("1: Scene's property grid.");
builder.AppendLine("2: Canvas's property grid.");
MessageBox.Show(builder.ToString());
}
}
internal Scene Create()
{
Scene scene = new Scene(Loader, Game);
scene.Name = Name;
foreach (Tuple<string, object> value in Values)
{
object assignable = LoaderUtil.MakeAssignable(value.Item2, scene);
scene[value.Item1] = assignable as ValueReader;
}
foreach (LoadedManager loadedManager in Managers)
{
IManager manager = loadedManager.CreateManager(scene);
scene.Managers.Add(manager);
scene.ManagersDictionary[manager.GetType()] = manager;
}
foreach (LoadedEntity loadedEntity in loadedEntities)
{
Entity entity = loadedEntity.Create(scene);
entity.Ready();
}
return scene;
}
public Color Integrate(Ray ray, Scene scene)
{
Color L = new Color();
Intersection intersection = null;
if (scene.Intersect(ray, out intersection))
{
foreach (Light thisLight in scene.Lights)
{
Math.Point lightPos = null;
Normal lightDir = null;
Color lightL = thisLight.L(intersection.Point, out lightPos, out lightDir);
if (!scene.Intersect(intersection.Point, lightPos))
{
float dot = System.Math.Max(0, Vector.Dot(intersection.Normal, lightDir));
Color texture = new Color(1, 1, 1);
if (intersection.Shape.Texture != null)
{
texture = intersection.Shape.Texture.Lookup(intersection.TextureCoordU, intersection.TextureCoordV);
}
L += (texture * intersection.Shape.BRDF.f(-ray.Direction, lightDir) * lightL * dot);
}
}
}
return L;
}
public HUDElementClass( Scene scene_current, short wizard = 0 )
: base()
{
CurrentScene = scene_current;
Parent = this;
Wizard = wizard;
}
/// <summary>
/// Create a new session using the given SessionParameters and Scene
/// </summary>
/// <param name="sessionParams">Previously created SessionParameters to create Session with</param>
/// <param name="scene">Previously created Scene to create Session with</param>
public Session(Client client, SessionParameters sessionParams, Scene scene)
{
Client = client;
SessionParams = sessionParams;
Scene = scene;
Id = CSycles.session_create(Client.Id, sessionParams.Id, scene.Id);
}
protected override Scene CreateScene()
{
var scene = new Scene("MainScene");
scene.Add(new ColorLayer("Background", Color.CornflowerBlue));
var spriteSheet = this.CreateSpriteSheet();
this.entityLayer = new SpriteLayer("EntityMap");
scene.Add(this.entityLayer);
this.playerShipEntity = new PlayerShipEntity(this.entityLayer, spriteSheet);
this.playerShipEntity.BindController(this.InputConfiguration);
scene.Add(this.playerShipEntity);
var yellowSprite = new Sprite(spriteSheet, "YellowEnemy") { Position = new Vector(250, 100) };
var redSprite = new Sprite(spriteSheet, "RedEnemy") { Position = new Vector(300, 100) };
var blueSprite = new Sprite(spriteSheet, "BlueEnemy") { Position = new Vector(350, 100) };
this.entityLayer.AddSprite(yellowSprite);
this.entityLayer.AddSprite(redSprite);
this.entityLayer.AddSprite(blueSprite);
return scene;
}
protected override void BeginTransitionOn()
{
spriteBatch = new SpriteBatch(device);
font = content.Load<SpriteFont>("Consolas");
scene = new Scene(kernel);
var camera = new EntityDescription(kernel);
camera.AddProperty(new TypedName<Camera>("camera"));
camera.AddProperty(new TypedName<Viewport>("viewport"));
camera.AddBehaviour<View>();
var cameraEntity = camera.Create();
cameraEntity.GetProperty(new TypedName<Camera>("camera")).Value = new Camera();
cameraEntity.GetProperty(new TypedName<Viewport>("viewport")).Value = new Viewport() { Height = 1920, Width = 1080 };
scene.Add(camera.Create());
var renderer = scene.GetService<Renderer>();
renderer.StartPlan()
.Then<A>()
.Then<B>()
.Then<C>()
.Then<D>()
.Apply();
base.OnShown();
}
private static void createScene()
{
XmlSerializer sceneSer = new XmlSerializer(typeof(Scene));
try
{
using (FileStream xmlStream = File.OpenRead(Constants.SCENE))
{
layout = (Scene)sceneSer.Deserialize(xmlStream);
}
}
catch (Exception e)
{
Console.WriteLine(e);
return;
}
foreach (SphereMaterial mat in layout.Spheres)
{
layout.Shapes.Add(new Sphere(mat));
}
foreach (PlaneMaterial mat in layout.Planes)
{
layout.Shapes.Add(new Plane(mat, Constants.FLOOR_SHADING));
}
layout.Cam.setup();
}
public MarkerNode getEquipMarkerNode(Scene scene)
{
int[] ids = new int[1];
ids[0] = 1;
//return new MarkerNode(scene.MarkerTracker, "Equipment.txt", ids); //ids[1]);
return new MarkerNode(scene.MarkerTracker, "EquipementMarkerConfig.txt", ids); //ids[1]);
}
public Form1()
{
InitializeComponent();
_openGLControl.InitializeContexts();
_openGLControl.SizeChanged += new EventHandler(OnOpenGLControlResized);
_input.Mouse = new Mouse(this, _openGLControl);
_input.Keyboard = new Keyboard(_openGLControl);
_scene = new Scene();
InitializeDisplay();
// InitializeSounds();
InitializeTextures();
// InitializeFonts();
InitializeGameState();
_layers = new Layers(_scene, _textureManager);
_layers.Show();
_modeComboBox.SelectedIndex = 1;
_fastLoop = new FastLoop(GameLoop);
}
static WaveBank mPermWaveBank; // one permanant wave bank
#endregion Fields
#region Methods
public static void Audio3Dupdate(Scene scene)
{
Audio3DCue c;
if (mActiveCueList != null)
{
setListener(scene);
for (int i = 0; i < mActiveCueList.Count; i++)
{
c = mActiveCueList[i];
if (c.cue.IsDisposed)
{
mCueStack.Push(c);
mActiveCueList.RemoveAt(i);
}
else if (!c.cue.IsDisposed && c.cue.IsStopped)
{
c.cue.Dispose();
mCueStack.Push(c);
mActiveCueList.RemoveAt(i);
}
else
apply3Daudio(c);
}
}
}
void OnLevelActivate(Scene scene, State state)
{
if (scene == Scene.Hub && state == State.Active)
{
StartCoroutine(StartGameTransition());
}
}
private void ClearOnSceneChange(Scene s1, Scene s2)
{
if (brackets != null)
{
brackets.Clear();
}
}
public PollServiceAssetEventArgs(string uri, UUID pId, Scene scene, string HGAssetSVC) :
base(null, uri, null, null, null, null, pId, int.MaxValue)
{
m_scene = scene;
m_hgassets = HGAssetSVC;
HasEvents = (requestID, agentID) =>
{
lock (responses)
{
APollResponse response;
if (responses.TryGetValue(requestID, out response))
{
ScenePresence sp = m_scene.GetScenePresence(pId);
if (sp == null || sp.IsDeleted)
{
return(true);
}
OSHttpResponse resp = response.osresponse;
if (Util.GetTimeStamp() - resp.RequestTS > (resp.RawBufferLen > 2000000 ? 10 : 5))
{
return(sp.CapCanSendAsset(2, resp.RawBufferLen));
}
if (resp.Priority > 0)
{
return(sp.CapCanSendAsset(resp.Priority, resp.RawBufferLen));
}
return(sp.CapCanSendAsset(2, resp.RawBufferLen));
}
return(false);
}
};
Drop = (requestID, y) =>
{
lock (responses)
{
responses.Remove(requestID);
lock (dropedResponses)
dropedResponses.Add(requestID);
}
};
GetEvents = (requestID, y) =>
{
lock (responses)
{
try
{
OSHttpResponse response = responses[requestID].osresponse;
if (response.Priority < 0)
{
response.Priority = 0;
}
Hashtable lixo = new Hashtable(1);
lixo["h"] = response;
return(lixo);
}
finally
{
responses.Remove(requestID);
}
}
};
// x is request id, y is request data hashtable
Request = (requestID, request) =>
{
APollRequest reqinfo = new APollRequest();
reqinfo.thepoll = this;
reqinfo.reqID = requestID;
reqinfo.request = request;
m_queue.Add(reqinfo);
return(null);
};
// this should never happen except possible on shutdown
NoEvents = (x, y) =>
{
/*
* lock (requests)
* {
* Hashtable request = requests.Find(id => id["RequestID"].ToString() == x.ToString());
* requests.Remove(request);
* }
*/
Hashtable response = new Hashtable();
response["int_response_code"] = 500;
response["str_response_string"] = "timeout";
response["content_type"] = "text/plain";
response["keepalive"] = false;
return(response);
};
}
void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
currentScene = scene;
if (currentScene.buildIndex != 1)
{
Debug.Log("This is Menu scene");
//GET ALL GAMEOBJECT
//THIS ONE IS FOR HIGHSCORE (SAME NAME as the one on Game scene)
highScore = GameObject.Find("HighScoreText").GetComponent <TextMeshProUGUI>();
highScore.text = "HighScore: \n" + PlayerPrefs.GetInt("HighScore", 0).ToString();
//THIS ONE IS FOR CHOICES TEXT
finalScore = GameObject.Find("ChoicesText").GetComponent <TextMeshProUGUI>();
finalScore.text = "Are you sure you want to\nreset? It will set your score\nback to 0.";
//THIS ONE IS FOR TRANSITION
deathUI = GameObject.FindObjectOfType <TransitionToGame>().gameObject;
deathUI.SetActive(false);
//THIS ONE IS FOR RESET MENU (To get Reset function)
crosshair = GameObject.Find("ResetChoice");
//THIS ONE IS FOR SETTINGS
gameUI = GameObject.Find("SettingsMenu");
//------------------
//GET ALL BUTTON
//THIS ONE IS FOR PLAY
deadRetryButton = GameObject.Find("PlayButton").GetComponent <Button>();
deadRetryButton.onClick.AddListener(() => Play());
//THIS ONE IS FOR QUIT
deadMainButton = GameObject.Find("QuitButton").GetComponent <Button>();
deadMainButton.onClick.AddListener(() => Quit());
//THIS ONE IS FOR RESET
pauseRetryButton = GameObject.Find("YesButton").GetComponent <Button>();
pauseRetryButton.onClick.AddListener(() => ResetScore());
crosshair.SetActive(false); // That way we could insert Reset onClick function first, then disable it. Don't know why it won't set to false if I place below MASTER VOLUME
//---------------------
//GET ALL SLIDER
//THIS ONE IS FOR MASTER VOLUME
masterSlider = GameObject.Find("MasterSlider").GetComponent <Slider>();
masterSlider.onValueChanged.AddListener(SetMusicLvl);
//THIS ONE IS FOR EFFECT VOLUME
effectSlider = GameObject.Find("EffectSlider").GetComponent <Slider>();
effectSlider.onValueChanged.AddListener(SetEffectLvl);
//-----------------
gameUI.SetActive(false);
masterSlider.value = PlayerPrefs.GetFloat("MasterSlider", 0); // It seems that I have to copy the value to here again as it will not take the slider value
effectSlider.value = PlayerPrefs.GetFloat("EffectSlider", 0);
}
else
{
Debug.Log("This is Game scene");
//SET THE COUNTER ALL TO 0 (Not going to broke something, but it was suppose to reset before creating singleton, so yeah
EnemyCounter = 0;
numberEnemyKilled = 0;
//GET ALL GAMEOBJECT TYPE
barUI = GameObject.FindObjectOfType <BarUI>();
deathUI = GameObject.Find("Death Canvas");
finalScore = GameObject.Find("Score text").GetComponent <TextMeshProUGUI>();
highScore = GameObject.Find("HighScoreText").GetComponent <TextMeshProUGUI>();
gameUI = GameObject.Find("Game Canvas");
crosshair = GameObject.Find("Crosshair");
PlayerStart = GameObject.Find("PlayerStart").transform;
//------------------------
//GET ALL BUTTON
pauseRetryButton = GameObject.Find("PauseRetryButton").GetComponent <Button>();
pauseRetryButton.onClick.AddListener(() => Retry());
pauseMainButton = GameObject.Find("PauseMainMenuButton").GetComponent <Button>();
pauseMainButton.onClick.AddListener(() => MainMenu());
deadRetryButton = GameObject.Find("DeadRetryButton").GetComponent <Button>();
deadRetryButton.onClick.AddListener(() => Retry());
deadMainButton = GameObject.Find("DeadMainMenuButton").GetComponent <Button>();
deadMainButton.onClick.AddListener(() => MainMenu());
//------------------------
//GET ALL SLIDER (SAME NAME as the one on Main scene)
masterSlider = GameObject.Find("MasterSlider").GetComponent <Slider>();
masterSlider.onValueChanged.AddListener(SetMusicLvl);
effectSlider = GameObject.Find("EffectSlider").GetComponent <Slider>();
effectSlider.onValueChanged.AddListener(SetEffectLvl);
//-----------------
//-----------------
deathUI.SetActive(false); // set false on here, that way all gameobject and button related to this can get before set false
// I don't set pauseUI off here since I did that on PauseUI script
}
SpawnPlayer(); // either way, it will check again for every scene changes
highScore.text = PlayerPrefs.GetInt("HighScore", 0).ToString();
//Get the slider value and set the audio again, works when changing scene except main scene
masterSlider.value = PlayerPrefs.GetFloat("MasterSlider", 0);
effectSlider.value = PlayerPrefs.GetFloat("EffectSlider", 0);
masterMixer.SetFloat("MusicVol", PlayerPrefs.GetFloat("MasterSlider", 0));
masterMixer.SetFloat("SFXVol", PlayerPrefs.GetFloat("EffectSlider", 0));
}
public void RegionLoaded(Scene scene)
{
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
BeginFade(-1);
}
public override void Awake(Scene scene)
{
base.Awake(scene);
awake = true;
if (!HasGroup)
{
MasterOfGroup = true;
Group = new List <CaveWall>();
GroupBoundsMin = new Point((int)X, (int)Y);
GroupBoundsMax = new Point((int)Right, (int)Bottom);
AddToGroupAndFindChildren(this);
Rectangle rectangle = new Rectangle(GroupBoundsMin.X / 8, GroupBoundsMin.Y / 8, (GroupBoundsMax.X - GroupBoundsMin.X) / 8 + 1, (GroupBoundsMax.Y - GroupBoundsMin.Y) / 8 + 1);
Level level = SceneAs <Level>();
Rectangle tileBounds = level.Session.MapData.TileBounds;
VirtualMap <char> virtualMap = level.SolidsData.Clone();
foreach (CaveWall item in Group)
{
int x = (int)(item.X / 8f) - level.Session.MapData.TileBounds.X;
int y = (int)(item.Y / 8f - level.Session.MapData.TileBounds.Y);
int tilesX = (int)(item.Width / 8f);
int tilesY = (int)(item.Height / 8f);
for (int i = x; i < x + tilesX; i++)
{
for (int j = y; j < y + tilesY; j++)
{
virtualMap[i, j] = item.fillTile;
}
}
}
// Pretend that the CaveWalls are just part of the map, then draw the CaveWalls on top of it
// This is a complicated solution to getting the CaveWalls to blend with both the foregroundTiles and each other
foreach (CaveWall item in Group)
{
int x = (int)item.X / 8 - tileBounds.Left;
int y = (int)item.Y / 8 - tileBounds.Top;
int tilesX = (int)item.Width / 8;
int tilesY = (int)item.Height / 8;
item.tiles = GFX.FGAutotiler.GenerateOverlay(item.fillTile, x, y, tilesX, tilesY, virtualMap).TileGrid;
item.Add(item.tiles);
item.Add(new TileInterceptor(item.tiles, highPriority: false));
}
}
TryToInitPosition();
if (CollideCheck <Player>())
{
tiles.Alpha = 0f;
fadeOut = true;
fadeIn = false;
cutout.Visible = false;
}
if (!disableTransitionFading)
{
TransitionListener transitionListener = new TransitionListener();
transitionListener.OnOut = OnTransitionOut;
transitionListener.OnOutBegin = OnTransitionOutBegin;
transitionListener.OnIn = OnTransitionIn;
transitionListener.OnInBegin = OnTransitionInBegin;
Add(transitionListener);
}
}
private void AddToGroupAndFindChildren(CaveWall from)
{
if (from.X < GroupBoundsMin.X)
{
GroupBoundsMin.X = (int)from.X;
}
if (from.Y < GroupBoundsMin.Y)
{
GroupBoundsMin.Y = (int)from.Y;
}
if (from.Right > GroupBoundsMax.X)
{
GroupBoundsMax.X = (int)from.Right;
}
if (from.Bottom > GroupBoundsMax.Y)
{
GroupBoundsMax.Y = (int)from.Bottom;
}
from.HasGroup = true;
Group.Add(from);
if (from != this)
{
from.master = this;
}
foreach (CaveWall entity in Scene.Tracker.GetEntities <CaveWall>())
{
if (!entity.HasGroup && (Scene.CollideCheck(new Rectangle((int)from.X - 1, (int)from.Y, (int)from.Width + 2, (int)from.Height), entity) || Scene.CollideCheck(new Rectangle((int)from.X, (int)from.Y - 1, (int)from.Width, (int)from.Height + 2), entity)))
{
AddToGroupAndFindChildren(entity);
}
}
}
public void Restart()
{
Scene loadedLevel = SceneManager.GetActiveScene();
SceneManager.LoadScene(loadedLevel.buildIndex);
}
internal static System.Drawing.Color[,] Render(int screenWidth, int screenHeight, int numSamples, Scene scene)
{
System.Drawing.Color[,] pixels = new System.Drawing.Color[screenWidth, screenHeight];
Camera camera = scene.Camera;
F64 sx = F64.Ratio(1, 2 * screenWidth);
F64 ox = F64.Half * F64.FromInt(screenWidth);
F64 sy = -F64.Ratio(1, 2 * screenHeight);
F64 oy = F64.Half * F64.FromInt(screenHeight);
F32 ooNumSamples = F32.Ratio(1, numSamples);
//for (int y = 0; y < screenHeight; y++)
Parallel.For(0, screenHeight, y =>
{
Random rnd = new Random(y * 29827341 + 23427343);
for (int x = 0; x < screenWidth; x++)
{
Color accum = Color.Black;
for (int i = 0; i < numSamples; i++)
{
// rx, ry == random offset in range [-0.5, 0.5]
F64 rx = F64.FromRaw(rnd.Next()) * 2 - F64.Half;
F64 ry = F64.FromRaw(rnd.Next()) * 2 - F64.Half;
F64 xx = (F64.FromInt(x) + rx - ox) * sx;
F64 yy = (F64.FromInt(y) + ry - oy) * sy;
F64Vec3 rayDir = F64Vec3.Normalize(camera.Forward + xx * camera.Right + yy * camera.Up);
Color color = TraceRay(new Ray(camera.Pos, rayDir), scene, 0);
accum += color;
}
pixels[x, y] = (ooNumSamples * accum).ToDrawingColor();
}
});
return(pixels);
}
private static Color GetNaturalColor(Material material, F64Vec3 pos, F64Vec3 norm, F64Vec3 rd, Scene scene)
{
Color ret = Color.Black;
foreach (Light light in scene.Lights)
{
F64Vec3 ldis = light.Pos - pos;
F64Vec3 livec = F64Vec3.NormalizeFastest(ldis);
ISect isect = IntersectRay(new Ray(pos, livec), scene);
bool isInShadow = (isect != null) && (isect.Dist * isect.Dist) < F64Vec3.LengthSqr(ldis);
if (!isInShadow)
{
F32 illum = F32.Max(F32.Zero, F64Vec3.Dot(livec, norm).F32);
Color lcolor = illum * light.Color;
F32 specular = F64Vec3.Dot(livec, F64Vec3.NormalizeFastest(rd)).F32;
Color scolor = specular > 0 ? F32.PowFastest(specular, material.Roughness) * light.Color : Color.Black;
ret += material.Diffuse * lcolor + material.Specular * scolor;
}
}
return(ret);
}
public virtual void RegionLoaded(Scene scene)
{
}
private void OnSceneUnloaded(Scene scene)
{
RefreshAudioListener();
}
private static Color GetReflectionColor(Material material, F64Vec3 pos, F64Vec3 norm, F64Vec3 rd, Scene scene, int depth)
{
return(material.Reflect * TraceRay(new Ray(pos, rd), scene, depth + 1));
}
void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
OnLevelLoaded(scene.buildIndex);
}
void ISceneTemplatePipeline.AfterTemplateInstantiation(SceneTemplateAsset sceneTemplateAsset, Scene scene, bool isAdditive, string sceneName)
{
}
private void OnSceneLoaded(Scene scene, LoadSceneMode sceneMode)
{
Initialize();
}
private void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
{
RefreshAudioListener();
}
protected override Task <bool> Initialize(EditorServiceGame editorGame)
{
game = (EntityHierarchyEditorGame)editorGame;
editorScene = game.EditorScene;
var transformMainGizmoRenderStage = new RenderStage("TransformGizmoOpaque", "Main");
var transformTransparentGizmoRenderStage = new RenderStage("TransformGizmoTransparent", "Main")
{
SortMode = new BackToFrontSortMode()
};
game.EditorSceneSystem.GraphicsCompositor.RenderStages.Add(transformMainGizmoRenderStage);
game.EditorSceneSystem.GraphicsCompositor.RenderStages.Add(transformTransparentGizmoRenderStage);
var meshRenderFeature = game.EditorSceneSystem.GraphicsCompositor.RenderFeatures.OfType <MeshRenderFeature>().First();
// Reset all stages for TransformationGrizmoGroup
meshRenderFeature.RenderStageSelectors.Add(new SimpleGroupToRenderStageSelector
{
RenderGroup = TransformationGizmo.TransformationGizmoGroupMask,
});
meshRenderFeature.RenderStageSelectors.Add(new MeshTransparentRenderStageSelector
{
EffectName = EditorGraphicsCompositorHelper.EditorForwardShadingEffect,
RenderGroup = TransformationGizmo.TransformationGizmoGroupMask,
OpaqueRenderStage = transformMainGizmoRenderStage,
TransparentRenderStage = transformTransparentGizmoRenderStage,
});
meshRenderFeature.PipelineProcessors.Add(new MeshPipelineProcessor {
TransparentRenderStage = transformTransparentGizmoRenderStage
});
var editorCompositor = (EditorTopLevelCompositor)game.EditorSceneSystem.GraphicsCompositor.Game;
editorCompositor.PostGizmoCompositors.Add(new ClearRenderer {
ClearFlags = ClearRendererFlags.DepthOnly
});
editorCompositor.PostGizmoCompositors.Add(new SingleStageRenderer {
RenderStage = transformMainGizmoRenderStage, Name = "Transform Opaque Gizmos"
});
editorCompositor.PostGizmoCompositors.Add(new SingleStageRenderer {
RenderStage = transformTransparentGizmoRenderStage, Name = "Transform Transparent Gizmos"
});
TranslationGizmo = new TranslationGizmo();
RotationGizmo = new RotationGizmo();
ScaleGizmo = new ScaleGizmo();
TranslationGizmo.TransformationEnded += OnGizmoTransformationFinished;
ScaleGizmo.TransformationEnded += OnGizmoTransformationFinished;
RotationGizmo.TransformationEnded += OnGizmoTransformationFinished;
transformationGizmos.Add(TranslationGizmo);
transformationGizmos.Add(RotationGizmo);
transformationGizmos.Add(ScaleGizmo);
Services.Get <IEditorGameEntitySelectionService>().SelectionUpdated += UpdateModifiedEntitiesList;
// Initialize and add the Gizmo entities to the gizmo scene
MicrothreadLocalDatabases.MountCommonDatabase();
// initialize the gizmo
foreach (var gizmo in transformationGizmos)
{
gizmo.Initialize(game.Services, editorScene);
}
// Deactivate all transformation gizmo by default
foreach (var gizmo in transformationGizmos)
{
gizmo.IsEnabled = false;
}
// set the default active transformation gizmo
ActiveTransformationGizmo = TranslationGizmo;
// Start update script (with priority 1 so that it happens after UpdateModifiedEntitiesList is called -- which usually happens from a EditorGameComtroller.PostAction() which has a default priority 0)
game.Script.AddTask(Update, 1);
return(Task.FromResult(true));
}
public UnlitColorMaterial(Scene scene, string name = "Unlit Material")
: base(scene)
{
Name = name;
}
/// <summary>
/// the method is activated at the event "SceneManager.sceneLoaded": the method
/// activates itself to the event: it activates an event that indicates the
/// beginning of a new scene.
/// </summary>
private void ManageNewScene(Scene scene, LoadSceneMode load)
{
EventsManager.CallEvent(EventAction.NewScene, GetActualLevel(scene));
}
void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
Debug.Log("OnSceneLoaded: " + scene.name + " " + mode);
}
// Start is called before the first frame update
void Start()
{
scene = SceneManager.GetActiveScene();
}
public override void BeforeRender(Scene scene)
{
DrawGears();
}
protected virtual void CreateWallBulletHole(Matrix world)
{
Scene.Add(new Props.BulletHolePlane1 {
WorldMatrix = world
});
}
/// <summary>
/// The method returns enumerator of actual scene, if the scene there is't, the method return null.
/// </summary>
private SceneEnum GetActualLevel(Scene scene)
{
return(EnumExtend.ParseEnum <SceneEnum>(scene.name));
}
//参数列表 必须与事件sceneLoaded一致
private void SceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
{
SceneManager.SetActiveScene(scene);
Debug.Log($"{sceneName}场景加载完毕！");
}
void Start()
{
current_scene = SceneManager.GetActiveScene();
sphere.AddForce(0, -0.5f, 0);
}
private async void Initialize()
{
// Create scene
Scene myScene = new Scene(Basemap.CreateImageryWithLabels())
{
// Set initial viewpoint
InitialViewpoint = new Viewpoint(_observerPoint, 1600)
};
// Create the elevation source
ElevationSource myElevationSource = new ArcGISTiledElevationSource(_elevationUri);
// Add the elevation source to the scene
myScene.BaseSurface.ElevationSources.Add(myElevationSource);
// Create the building scene layer
ArcGISSceneLayer mySceneLayer = new ArcGISSceneLayer(_buildingsUri);
// Add the building layer to the scene
myScene.OperationalLayers.Add(mySceneLayer);
// Add the observer to the scene
// Create a graphics overlay with relative surface placement; relative surface placement allows the Z position of the observation point to be adjusted
GraphicsOverlay overlay = new GraphicsOverlay()
{
SceneProperties = new LayerSceneProperties(SurfacePlacement.Relative)
};
// Create the symbol that will symbolize the observation point
SimpleMarkerSceneSymbol symbol = new SimpleMarkerSceneSymbol(SimpleMarkerSceneSymbolStyle.Sphere, Colors.Red, 10, 10, 10, SceneSymbolAnchorPosition.Bottom);
// Create the observation point graphic from the point and symbol
_observerGraphic = new Graphic(_observerPoint, symbol);
// Add the observer to the overlay
overlay.Graphics.Add(_observerGraphic);
// Add the overlay to the scene
MySceneView.GraphicsOverlays.Add(overlay);
try
{
// Add the taxi to the scene
// Create the model symbol for the taxi
ModelSceneSymbol taxiSymbol = await ModelSceneSymbol.CreateAsync(new Uri(GetModelUri()));
// Set the anchor position for the mode; ensures that the model appears above the ground
taxiSymbol.AnchorPosition = SceneSymbolAnchorPosition.Bottom;
// Create the graphic from the taxi starting point and the symbol
_taxiGraphic = new Graphic(_points[0], taxiSymbol);
// Add the taxi graphic to the overlay
overlay.Graphics.Add(_taxiGraphic);
// Create GeoElement Line of sight analysis (taxi to building)
// Create the analysis
_geoLine = new GeoElementLineOfSight(_observerGraphic, _taxiGraphic)
{
// Apply an offset to the target. This helps avoid some false negatives
TargetOffsetZ = 2
};
// Create the analysis overlay
AnalysisOverlay myAnalysisOverlay = new AnalysisOverlay();
// Add the analysis to the overlay
myAnalysisOverlay.Analyses.Add(_geoLine);
// Add the analysis overlay to the scene
MySceneView.AnalysisOverlays.Add(myAnalysisOverlay);
// Create a timer; this will enable animating the taxi
Device.StartTimer(new TimeSpan(0, 0, 0, 0, 60), () =>
{
// Move the taxi every time the timer elapses
AnimationTimer_Elapsed(this, null);
// Keep the timer running
return(true);
});
// Subscribe to TargetVisible events; allows for updating the UI and selecting the taxi when it is visible
_geoLine.TargetVisibilityChanged += Geoline_TargetVisibilityChanged;
// Add the scene to the view
MySceneView.Scene = myScene;
}
catch (Exception e)
{
await Application.Current.MainPage.DisplayAlert("Error", e.ToString(), "OK");
}
}
protected virtual void CreateGroundBulletHole(Vector3 position)
{
Scene.Add(new Props.BulletHoleDecal1 {
Translation = position
});
}
// Start is called before the first frame update
void Start()
{
Answers = AnswerBox.GetComponent <AnswerTrigger>();
this.scene = SceneManager.GetActiveScene();
}
private void SceneManagerOnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
{
GameStateHelper.GameState = scene.name.ToLower().Contains("level") ? GameState.Playing : GameState.Menu;
}
