public PostProcessingGraphicsScreen(IServiceLocator services) : base(services.GetInstance<IGraphicsService>()) { _sampleFramework = services.GetInstance<SampleFramework>(); _spriteBatch = new SpriteBatch(GraphicsService.GraphicsDevice); _clearGBufferRenderer = new ClearGBufferRenderer(GraphicsService); _rebuildZBufferRenderer = new RebuildZBufferRenderer(GraphicsService); _meshRenderer = new MeshRenderer(); _skyRenderer = new SkyRenderer(GraphicsService); _billboardRenderer = new BillboardRenderer(GraphicsService, 2048); Scene = new Scene(); PostProcessors = new PostProcessorChain(GraphicsService); // Use 2D texture for reticle. var contentManager = services.GetInstance<ContentManager>(); _reticle = contentManager.Load<Texture2D>("Reticle"); // Use the sprite font of the GUI. var uiContentManager = services.GetInstance<ContentManager>("UIContent"); var spriteFont = uiContentManager.Load<SpriteFont>("UI Themes/BlendBlue/Default"); DebugRenderer = new DebugRenderer(GraphicsService, spriteFont) { DefaultColor = new Color(0, 0, 0), DefaultTextPosition = new Vector2F(10), }; }
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); }
public ProxyNodeSample(Microsoft.Xna.Framework.Game game) : base(game) { SampleFramework.IsMouseVisible = false; var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService) { RenderCallback = Render, }; GraphicsService.Screens.Insert(0, delegateGraphicsScreen); _renderer = new MeshRenderer(); // Add a custom game object which controls the camera. _cameraObject = new CameraObject(Services); GameObjectService.Objects.Add(_cameraObject); _scene = new Scene(); SceneSample.InitializeDefaultXnaLights(_scene); // For advanced users: Set this flag if you want to analyze the imported opaque data of // effect bindings. EffectBinding.KeepOpaqueData = true; // Original model in scene graph. var modelNode = ContentManager.Load<ModelNode>("Dude/Dude").Clone(); modelNode.PoseLocal = new Pose(new Vector3F(-2, 0, 0)); var meshNode = modelNode.GetSubtree().OfType<MeshNode>().First(); _scene.Children.Add(modelNode); // Clone referenced by proxy node. var modelNode2 = modelNode.Clone(); var meshNode2 = modelNode2.GetSubtree().OfType<MeshNode>().First(); meshNode2.SkeletonPose = meshNode.SkeletonPose; _proxyNode = new ProxyNode(null) { Name = "Proxy", PoseLocal = new Pose(new Vector3F(2, 0, 0), Matrix33F.CreateRotationY(ConstantsF.Pi)), ScaleLocal = new Vector3F(0.5f), }; _scene.Children.Add(_proxyNode); _proxyNode.Node = modelNode2; var spriteFont = UIContentManager.Load<SpriteFont>("UI Themes/BlendBlue/Default"); _debugRenderer = new DebugRenderer(GraphicsService, spriteFont); var mesh = meshNode.Mesh; foreach (var m in mesh.Materials) { //((ConstParameterBinding<Vector3>)m["Default"].ParameterBindings["SpecularColor"]).Value = new Vector3(); ((SkinnedEffectBinding)m["Default"]).PreferPerPixelLighting = true; } var timeline = new TimelineClip(mesh.Animations.Values.First()) { Duration = TimeSpan.MaxValue, LoopBehavior = LoopBehavior.Cycle, }; AnimationService.StartAnimation(timeline, (IAnimatableProperty)meshNode.SkeletonPose); }
public ProjectedShadowSample(Microsoft.Xna.Framework.Game game) : base(game) { SampleFramework.IsMouseVisible = false; var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService) { RenderCallback = Render, }; GraphicsService.Screens.Insert(0, delegateGraphicsScreen); // Create a new empty scene. _scene = new Scene(); Services.Register(typeof(IScene), null, _scene); // Add a custom game object which controls the camera. _cameraObject = new CameraObject(Services); _cameraObject.ResetPose(new Vector3F(-8, 6, 8), -ConstantsF.PiOver4, -0.4f); GameObjectService.Objects.Add(_cameraObject); // Add a default light setup (ambient light + 3 directional lights). var defaultLightsObject = new DefaultLightsObject(Services); GameObjectService.Objects.Add(defaultLightsObject); // Get the main directional light. _mainDirectionalLightNode = ((LightNode)_scene.GetSceneNode("KeyLight")); // Add a ground plane model to the scene graph. var grid = ContentManager.Load<ModelNode>("Ground/Ground").Clone(); grid.ScaleLocal = new Vector3F(0.3f); _scene.Children.Add(grid); // Add a tank model to the scene graph. var tank = ContentManager.Load<ModelNode>("Tank/tank").Clone(); _scene.Children.Add(tank); // Remember the mesh nodes of tank node. _tankMeshNodes = tank.GetSubtree().Where(n => n is MeshNode).ToArray(); // Create the renderers. _meshRenderer = new MeshRenderer(); var spriteFont = UIContentManager.Load<SpriteFont>("UI Themes/BlendBlue/Default"); _debugRenderer = new DebugRenderer(GraphicsService, spriteFont); _projectedShadowRenderer = new ProjectedShadowRenderer(GraphicsService) { // The plane onto which the shadows are projected. It is positioned a bit above the ground // plane to avoid z-fighting. ShadowedPlane = new Plane(new Vector3F(0, 1, 0), 0.01f), // The shadow color is a transparent black. ShadowColor = new Vector4F(0, 0, 0, 0.4f), // The light position is set in Update(). //LightPosition = ... }; }
public SampleGraphicsScreen(IServiceLocator services) : base(services.GetInstance<IGraphicsService>()) { _sampleFramework = services.GetInstance<SampleFramework>(); Name = "SampleScreen"; ClearBackground = false; BackgroundColor = new Color(220, 220, 220); DrawReticle = false; UseFixedWidthFont = false; // Use 2D texture for reticle. var contentManager = services.GetInstance<ContentManager>(); _reticle = contentManager.Load<Texture2D>("Reticle"); // Get the sprite fonts used in the UI theme. var uiContentManager = services.GetInstance<ContentManager>("UIContent"); _defaultFont = uiContentManager.Load<SpriteFont>("UI Themes/BlendBlue/Default"); _fixedWidthFont = uiContentManager.Load<SpriteFont>("UI Themes/BlendBlue/Console"); // Set up 2D camera such that (0, 0) is upper, left corner of screen and // (screenWidth, screenHeight) is lower, right corner of screen. var graphicsDevice = GraphicsService.GraphicsDevice; int screenWidth = graphicsDevice.PresentationParameters.BackBufferWidth; int screenHeight = graphicsDevice.PresentationParameters.BackBufferHeight; var projection = new OrthographicProjection { Near = 0, Far = 2000, Left = 0, Right = screenWidth, Top = 0, Bottom = screenHeight, }; var camera = new Camera(projection); _cameraNode2D = new CameraNode(camera) { PoseWorld = new Pose(new Vector3F(0, 0, 1000)), }; // Initialize renderers. _spriteBatch = new SpriteBatch(graphicsDevice); _meshRenderer = new MeshRenderer(); _billboardRenderer = new BillboardRenderer(GraphicsService, 2048); DebugRenderer2D = new DebugRenderer(GraphicsService, _defaultFont) { SpriteFont = _defaultFont, DefaultColor = new Color(0, 0, 0), DefaultTextPosition = new Vector2F(10) }; DebugRenderer = new DebugRenderer(GraphicsService, _defaultFont) { SpriteFont = _defaultFont, DefaultColor = new Color(0, 0, 0), DefaultTextPosition = new Vector2F(10) }; Scene = new Scene(); }
//public DebugRenderer DebugRenderer { get; private set; } public GameScreen(IGraphicsService graphicsService) : base(graphicsService) { var content = ServiceLocator.Current.GetInstance<ContentManager>(); var meshRenderer = new MeshRenderer(); _opaqueSceneRenderer = new SceneRenderer(); _opaqueSceneRenderer.Renderers.Add(meshRenderer); //DebugRenderer = ServiceLocator.Current.GetInstance<DebugRenderer>(); Scene = new Scene(); }
public BasicScreen(IGraphicsService graphics) : base(graphics) { var game = ServiceLocator.Current.GetInstance<Game>(); Map = new Dictionary<int,ICT309Game.Container.ModelContainer>(); // NumModels = 0; //Models = new List<Model>(); // Poses = new List<Pose>(); // SkeletonPoses = new List<SkeletonPose>(); Scene = new Scene(); ActiveCamera = null; _renderer = new MeshRenderer(); }
public WeightedBlendedOITScreen(IServiceLocator services) : base(services.GetInstance<IGraphicsService>()) { Coverage = GraphicsScreenCoverage.Full; Scene = new Scene(); EnableWboit = true; _meshRenderer = new MeshRenderer(); var content = services.GetInstance<ContentManager>(); _wboitEffect = content.Load<Effect>("WeightedBlendedOIT/WeightedBlendedOIT"); _parameterViewportSize = _wboitEffect.Parameters["ViewportSize"]; _parameterTextureA = _wboitEffect.Parameters["TextureA"]; _parameterTextureB = _wboitEffect.Parameters["TextureB"]; }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="BasicGraphicsScreen"/> class. /// </summary> /// <param name="services">The services.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="services"/> is <see langword="null"/>. /// </exception> public BasicGraphicsScreen(IServiceLocator services) : base(services?.GetInstance<IGraphicsService>()) { if (services == null) throw new ArgumentNullException(nameof(services)); _meshRenderer = new MeshRenderer(); _billboardRenderer = new BillboardRenderer(GraphicsService, 2048); var contentManager = services.GetInstance<ContentManager>(); var spriteFont = contentManager.Load<SpriteFont>("DigitalRune.Editor.Game/Fonts/DejaVuSans"); DebugRenderer = new DebugRenderer(GraphicsService, spriteFont); Scene = new Scene(); }
public override void Initialize() { var delegateGraphics = new DelegateGraphicsScreen(_graphicsService) { RenderCallback = Render, }; _graphicsService.Screens.Add(delegateGraphics); // Initialise components _camera = new CameraComponent(this); _meshRenderer = new MeshRenderer(); Console.WriteLine("GameScreen"); base.Initialize(); }
public InstancingSample(Microsoft.Xna.Framework.Game game) : base(game) { SampleFramework.IsMouseVisible = false; var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService) { RenderCallback = Render, }; GraphicsService.Screens.Insert(0, delegateGraphicsScreen); // Add a custom game object which controls the camera. _cameraObject = new CameraObject(Services); GameObjectService.Objects.Add(_cameraObject); _scene = new Scene(); _scene.Children.Add(_cameraObject.CameraNode); // Add a lot of instances of one model to the scene. This model uses a custom // shader which supports instancing. See the *.drmdl, *.drmat and *.fx files // in the directory of the FBX file. var model = ContentManager.Load<ModelNode>("InstancedModel/InstancedModel"); for (int x = 1; x < 50; x++) { for (int z = 1; z < 20; z++) { var clone = model.Clone(); Pose pose = clone.PoseLocal; pose.Position.X -= x; pose.Position.Z -= z; clone.PoseLocal = pose; clone.ScaleLocal = new Vector3F(0.7f); SetRandomColorAndAlpha(clone); _scene.Children.Add(clone); } } SceneSample.InitializeDefaultXnaLights(_scene); _meshRenderer = new MeshRenderer(); }
public AvatarAttachmentSample(Microsoft.Xna.Framework.Game game) : base(game) { SampleFramework.IsMouseVisible = false; // This sample uses Scene and MeshRenderer for rendering the attached models. _scene = new Scene(); _meshRenderer = new MeshRenderer(); // Add a custom game object which controls the camera. _cameraObject = new CameraObject(Services); _cameraObject.ResetPose(new Vector3F(0, 1, -3), ConstantsF.Pi, 0); GameObjectService.Objects.Add(_cameraObject); // Create a random avatar. _avatarDescription = AvatarDescription.CreateRandom(); _avatarRenderer = new AvatarRenderer(_avatarDescription); // Load walk animation using the content pipeline. TimelineGroup animation = ContentManager.Load<TimelineGroup>("XboxAvatars/Walk"); // Create a looping walk animation. _walkAnimation = new TimelineClip(animation) { LoopBehavior = LoopBehavior.Cycle, // Cycle Walk animation... Duration = TimeSpan.MaxValue, // ...forever. }; var baseballBatModelNode = ContentManager.Load<ModelNode>("XboxAvatars/BaseballBat").Clone(); _baseballBatMeshNode = baseballBatModelNode.GetChildren().OfType<MeshNode>().First(); // If we only render the baseball bat, it appears black. We need to add it to // a scene with some lights. (The lights do not affect the avatar.) SceneSample.InitializeDefaultXnaLights(_scene); // We must detach the mesh node from its current parent (the model node) before // we can add it to the scene. _baseballBatMeshNode.Parent.Children.Remove(_baseballBatMeshNode); _scene.Children.Add(_baseballBatMeshNode); }
public IntersectionSample(Microsoft.Xna.Framework.Game game) : base(game) { SampleFramework.IsMouseVisible = false; var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService) { RenderCallback = Render, }; GraphicsService.Screens.Insert(0, delegateGraphicsScreen); // Add a custom game object which controls the camera. _cameraObject = new CameraObject(Services, 10); _cameraObject.ResetPose(new Vector3F(0, 0, -4), ConstantsF.Pi, 0); GameObjectService.Objects.Add(_cameraObject); // Create a new scene with some lights. _scene = new Scene(); SceneSample.InitializeDefaultXnaLights(_scene); _meshRenderer = new MeshRenderer(); _debugRenderer = new DebugRenderer(GraphicsService, null); _intersectionRenderer = new IntersectionRenderer(GraphicsService, ContentManager) { DownsampleFactor = 1, }; //_submeshA = MeshHelper.CreateSubmesh(GraphicsService.GraphicsDevice, new SphereShape(0.5f).GetMesh(0.001f, 5), MathHelper.ToRadians(70)); //_submeshB = MeshHelper.CreateSubmesh(GraphicsService.GraphicsDevice, new BoxShape(1, 1, 2).GetMesh(0.001f, 5), MathHelper.ToRadians(70)); var meshNodeA = CreateMeshNode(new[] { MeshHelper.CreateTorus(GraphicsService.GraphicsDevice, 1, 0.3f, 30), MeshHelper.CreateSubmesh(GraphicsService.GraphicsDevice, new BoxShape(1, 1, 2).GetMesh(0.001f, 5), MathHelper.ToRadians(70)), }, Color.DarkBlue); meshNodeA.PoseWorld = new Pose(RandomHelper.Random.NextVector3F(-0.5f, 0.5f), RandomHelper.Random.NextQuaternionF()); _scene.Children.Add(meshNodeA); _debugRenderer.DrawObject(meshNodeA, Color.Green, true, false); var shape = new TransformedShape( new GeometricObject(new SphereShape(0.5f), new Pose(new Vector3F(1, 0, 0)))); var meshNodeB = CreateMeshNode(new[] { MeshHelper.CreateTorus(GraphicsService.GraphicsDevice, 1, 0.3f, 30), MeshHelper.CreateSubmesh(GraphicsService.GraphicsDevice, shape.GetMesh(0.001f, 4), MathHelper.ToRadians(90)), }, Color.Gray); meshNodeB.PoseWorld = new Pose(RandomHelper.Random.NextVector3F(-1f, 1f), RandomHelper.Random.NextQuaternionF()); _scene.Children.Add(meshNodeB); _debugRenderer.DrawObject(meshNodeB, Color.Green, true, false); var meshNodeC = CreateMeshNode(new[] { MeshHelper.CreateBox(GraphicsService.GraphicsDevice), MeshHelper.CreateSubmesh(GraphicsService.GraphicsDevice, new BoxShape(1, 1, 2).GetMesh(0.001f, 5), MathHelper.ToRadians(70)) }, Color.DarkGreen); meshNodeC.PoseWorld = new Pose(RandomHelper.Random.NextVector3F(-1f, 1f), RandomHelper.Random.NextQuaternionF()); meshNodeC.ScaleLocal = new Vector3F(0.1f, 1f, 0.5f); _scene.Children.Add(meshNodeC); _debugRenderer.DrawObject(meshNodeC, Color.Green, true, false); _meshNodePairs.Add(new Pair<MeshNode>(meshNodeA, meshNodeB)); _meshNodePairs.Add(new Pair<MeshNode>(meshNodeA, meshNodeC)); _meshNodePairs.Add(new Pair<MeshNode>(meshNodeB, meshNodeC)); CreateGuiControls(); }
private void AddHealthbar() { healthbar = GameObject.Instantiate(healthbarTemplate, transform.position, transform.rotation) as GameObject; healthbar.name = "healthbar"; healthbar.transform.position = new Vector3(transform.position.x, transform.position.y + 2f, transform.position.z); healthbar.transform.parent = transform; healthbarHealth = healthbar.transform.Find("health").GetComponent<MeshRenderer>() as MeshRenderer; healthbarBg = healthbar.transform.Find("background").GetComponent<MeshRenderer>() as MeshRenderer; SetHealthbar(false, 0f); }
private void CreateControllerModel(NxrInstantNativeApi.NibiruDeviceType deviceType, string objName, InteractionManager.ControllerConfig mControllerConfig) { string objPath = mControllerConfig.objPath; if (deviceType == NxrInstantNativeApi.NibiruDeviceType.LeftController) { objPath = mControllerConfig.leftCtrlObjPath; } else if (deviceType == NxrInstantNativeApi.NibiruDeviceType.RightController) { objPath = mControllerConfig.rightCtrlObjPath; } if (objPath == null) { Debug.LogError("CreateControllerModel failed, objPath is null......" + objName); return; } GameObject go = new GameObject(objName); NxrLaserPointer mNxrLaserPointer = go.AddComponent <NxrLaserPointer>(); mNxrLaserPointer.deviceType = deviceType; go.transform.SetParent(transformCache); go.transform.localScale = Vector3.one; go.transform.localPosition = new Vector3(0, 0, 0); go.transform.localRotation = new Quaternion(0, 0, 0, 1); GameObject modelGOParent = new GameObject("model_P"); modelGOParent.transform.localScale = new Vector3(-1, 1, 1); modelGOParent.transform.localPosition = new Vector3(0, 0, 0); modelGOParent.transform.localRotation = new Quaternion(0, 0, 0, 1); modelGOParent.transform.SetParent(go.transform); GameObject modelGO = new GameObject("model"); modelGO.transform.SetParent(modelGOParent.transform); modelGO.transform.localScale = new Vector3(mControllerConfig.modelScale[0] , mControllerConfig.modelScale[1], mControllerConfig.modelScale[2]); modelGO.transform.localRotation = Quaternion.Euler(mControllerConfig.modelRotation[0], mControllerConfig.modelRotation[1], mControllerConfig.modelRotation[2]); modelGO.transform.localPosition = new Vector3(mControllerConfig.modelPosition[0] , mControllerConfig.modelPosition[1], mControllerConfig.modelPosition[2]); modelGO.AddComponent <NxrControllerModel>(); // string objPath = "/system/etc/Objs/housing_bott.obj"; Debug.Log("objPath=" + objPath); ObjModelLoader mObjModelLoader = go.GetComponent <ObjModelLoader>(); if (mObjModelLoader == null) { go.AddComponent <ObjMaterial>(); mObjModelLoader = go.AddComponent <ObjModelLoader>(); } mObjModelLoader.LoadObjFile(objPath, modelGO.transform); GameObject powerGO = new GameObject("Power"); powerGO.transform.SetParent(go.transform); MeshRenderer powerMeshRenderer = powerGO.AddComponent <MeshRenderer>(); Mesh quadMesh = new Mesh(); quadMesh.name = "QUAD"; float quadSize = 0.5f; quadMesh.vertices = new Vector3[] { new Vector3(-1 * quadSize, -1 * quadSize, 0), new Vector3(-1 * quadSize, 1 * quadSize, 0), new Vector3(1 * quadSize, 1 * quadSize, 0), new Vector3(1 * quadSize, -1 * quadSize, 0) }; quadMesh.uv = new Vector2[] { new Vector2(0, 0), new Vector2(0, 1), new Vector2(1, 1), new Vector2(1, 0) }; int[] triangles = { 0, 1, 2, 0, 2, 3 }; quadMesh.triangles = triangles; powerGO.AddComponent <MeshFilter>().mesh = quadMesh; powerGO.AddComponent <MeshCollider>(); powerGO.AddComponent <NibiruControllerPower>(); powerGO.transform.localPosition = new Vector3(mControllerConfig.batteryPosition[0], mControllerConfig.batteryPosition[1] , mControllerConfig.batteryPosition[2]); powerGO.transform.localRotation = Quaternion.Euler(mControllerConfig.batteryRotation[0], mControllerConfig.batteryRotation[1] , mControllerConfig.batteryRotation[2]); powerGO.transform.localScale = new Vector3(mControllerConfig.batteryScale[0], mControllerConfig.batteryScale[1] , mControllerConfig.batteryScale[2]); // 射线起点 mNxrLaserPointer.SetHolderLocalPosition(new Vector3(mControllerConfig.rayStartPosition[0], mControllerConfig.rayStartPosition[1], mControllerConfig.rayStartPosition[2])); NxrTrackedDevice trackedDevice = go.AddComponent <NxrTrackedDevice>(); if (trackedDevice != null) { trackedDevice.ReloadLaserPointer(mNxrLaserPointer); trackedDevice.deviceType = deviceType; InteractionManager.NACTION_HAND_TYPE mHandType = deviceType == NxrInstantNativeApi.NibiruDeviceType.LeftController ? InteractionManager.NACTION_HAND_TYPE.HAND_LEFT : InteractionManager.NACTION_HAND_TYPE.HAND_RIGHT; if (!DualCtrlDeviceDict.ContainsKey(mHandType)) { DualCtrlDeviceDict.Add(mHandType, trackedDevice); } else { DualCtrlDeviceDict[mHandType] = trackedDevice; } } if (deviceType == NxrInstantNativeApi.NibiruDeviceType.LeftController) { leftObj = go; leftModelGo = modelGO; } else if (deviceType == NxrInstantNativeApi.NibiruDeviceType.RightController) { rightObj = go; rightModelGo = modelGO; } //close NxrViewer.Instance.SwitchControllerMode(true); Debug.Log("HideGaze.ForceUseReticle3"); }
void Start() { RunnerRigidBody = GetComponent <Rigidbody>(); RunnerRenderer = GetComponent <MeshRenderer>(); RunnerCollision = this.GetComponent <BoxCollider>(); }
void Start() { input = PlayerInput.instance; rend = this.GetComponent <MeshRenderer>(); }
public BillboardSample(Microsoft.Xna.Framework.Game game) : base(game) { SampleFramework.IsMouseVisible = false; var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService) { RenderCallback = Render, }; GraphicsService.Screens.Insert(0, delegateGraphicsScreen); // Add a custom game object which controls the camera. _cameraObject = new CameraObject(Services); GameObjectService.Objects.Add(_cameraObject); // In this example we need three renderers: // The MeshRenderer handles MeshNodes. _meshRenderer = new MeshRenderer(); // The BillboardRenderer handles BillboardNodes and ParticleSystemNodes. _billboardRenderer = new BillboardRenderer(GraphicsService, 2048); // The DebugRenderer is used to draw text. var spriteFont = UIContentManager.Load<SpriteFont>("UI Themes/BlendBlue/Default"); _debugRenderer = new DebugRenderer(GraphicsService, spriteFont); // Create a new empty scene. _scene = new Scene(); // Add the camera node to the scene. _scene.Children.Add(_cameraObject.CameraNode); // Add a few models to the scene. var sandbox = ContentManager.Load<ModelNode>("Sandbox/Sandbox").Clone(); _scene.Children.Add(sandbox); // Add some lights to the scene which have the same properties as the lights // of BasicEffect.EnableDefaultLighting(). SceneSample.InitializeDefaultXnaLights(_scene); var texture = new PackedTexture(ContentManager.Load<Texture2D>("Billboard/BillboardReference")); // ----- View plane-aligned billboards with variations. // View plane-aligned billboards are rendered parallel to the screen. // The up-axis of the BillboardNode determines the up direction of the // billboard. var pose0 = new Pose(new Vector3F(-9, 1.0f, 1.5f)); var pose1 = pose0; var billboard = new ImageBillboard(texture); var billboardNode = new BillboardNode(billboard); billboardNode.Name = "View plane-aligned\nVarying color\nVarying alpha"; billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; billboardNode.Color = new Vector3F(1, 0, 0); billboardNode.Alpha = 0.9f; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; billboardNode.Color = new Vector3F(0, 1, 0); billboardNode.Alpha = 0.7f; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; billboardNode.Color = new Vector3F(0, 0, 1); billboardNode.Alpha = 0.3f; _scene.Children.Add(billboardNode); // ----- View plane-aligned billboards with different blend modes // blend mode = 0 ... additive blend // blend mode = 1 ... alpha blend pose0.Position.X += 2; pose1 = pose0; billboard = new ImageBillboard(texture); billboard.BlendMode = 0.0f; billboardNode = new BillboardNode(billboard); billboardNode.Name = "View plane-aligned\nVarying blend mode"; billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboard = new ImageBillboard(texture); billboard.BlendMode = 0.333f; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboard = new ImageBillboard(texture); billboard.BlendMode = 0.667f; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboard = new ImageBillboard(texture); billboard.BlendMode = 1.0f; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); // ----- View plane-aligned billboards with alpha test pose0.Position.X += 2; pose1 = pose0; billboard = new ImageBillboard(texture); billboard.AlphaTest = 0.9f; billboardNode = new BillboardNode(billboard); billboardNode.Name = "View plane-aligned\nVarying reference alpha"; billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboard = new ImageBillboard(texture); billboard.AlphaTest = 0.667f; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboard = new ImageBillboard(texture); billboard.AlphaTest = 0.333f; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboard = new ImageBillboard(texture); billboard.AlphaTest = 0.0f; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); // ----- View plane-aligned billboards with different scale and rotation pose0.Position.X += 2; pose1 = pose0; billboard = new ImageBillboard(texture); billboard.Orientation = BillboardOrientation.ViewPlaneAligned; billboardNode = new BillboardNode(billboard); billboardNode.Name = "View plane-aligned\nVarying scale\nVarying rotation"; billboardNode.PoseWorld = pose1; billboardNode.ScaleLocal = new Vector3F(0.4f); _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = billboardNode.Clone(); billboardNode.Name = null; billboardNode.PoseWorld = pose1 * new Pose(Matrix33F.CreateRotationZ(MathHelper.ToRadians(-15))); billboardNode.ScaleLocal = new Vector3F(0.6f); _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = billboardNode.Clone(); billboardNode.Name = null; billboardNode.PoseWorld = pose1 * new Pose(Matrix33F.CreateRotationZ(MathHelper.ToRadians(-30))); billboardNode.ScaleLocal = new Vector3F(0.8f); _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = billboardNode.Clone(); billboardNode.Name = null; billboardNode.PoseWorld = pose1 * new Pose(Matrix33F.CreateRotationZ(MathHelper.ToRadians(-45))); billboardNode.ScaleLocal = new Vector3F(1.0f); _scene.Children.Add(billboardNode); // ----- Viewpoint-oriented billboards // Viewpoint-orientated billboards always face the player. (The face normal // points directly to the camera.) pose0.Position.X += 2; pose1 = pose0; billboard = new ImageBillboard(texture); billboard.Orientation = BillboardOrientation.ViewpointOriented; billboardNode = new BillboardNode(billboard); billboardNode.Name = "Viewpoint-oriented"; billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); // ----- Screen-aligned billboards // View plane-aligned billboards and screen-aligned billboards are similar. The // billboards are rendered parallel to the screen. The orientation can be changed // by rotating the BillboardNode. The difference is that the orientation of view // plane-aligned billboards is relative to world space and the orientation of // screen-aligned billboards is relative to view space. // Screen-aligned billboards are, for example, used for text label. pose0.Position.X += 2; pose1 = pose0; billboard = new ImageBillboard(texture); billboard.Orientation = BillboardOrientation.ScreenAligned; billboardNode = new BillboardNode(billboard); billboardNode.Name = "Screen-aligned"; billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); // ----- Axial, view plane-aligned billboards pose0.Position.X += 2; pose1 = pose0; billboard = new ImageBillboard(texture); billboard.Orientation = BillboardOrientation.AxialViewPlaneAligned; billboardNode = new BillboardNode(billboard); billboardNode.Name = "Axial, view plane-aligned"; billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = billboardNode.Clone(); billboardNode.Name = null; billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); // ----- Axial, viewpoint-oriented billboards pose0.Position.X += 2; pose1 = pose0; billboard = new ImageBillboard(texture); billboard.Orientation = BillboardOrientation.AxialViewpointOriented; billboardNode = new BillboardNode(billboard); billboardNode.Name = "Axial, viewpoint-oriented"; billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); // ----- World-oriented billboards // World-oriented billboards have a fixed orientation in world space. The // orientation is determine by the BillboardNode. pose0.Position.X += 2; pose1 = pose0; pose1.Orientation *= Matrix33F.CreateRotationY(0.2f); billboard = new ImageBillboard(texture); billboard.Orientation = BillboardOrientation.WorldOriented; billboardNode = new BillboardNode(billboard); billboardNode.Name = "World-oriented"; billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; pose1.Orientation *= Matrix33F.CreateRotationY(0.2f); billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1 * new Pose(Matrix33F.CreateRotationZ(MathHelper.ToRadians(15))); _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; pose1.Orientation *= Matrix33F.CreateRotationY(0.2f); billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1 * new Pose(Matrix33F.CreateRotationZ(MathHelper.ToRadians(30))); _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; pose1.Orientation *= Matrix33F.CreateRotationY(0.2f); billboardNode = new BillboardNode(billboard); billboardNode.PoseWorld = pose1 * new Pose(Matrix33F.CreateRotationZ(MathHelper.ToRadians(45))); _scene.Children.Add(billboardNode); // ----- Animated billboards // DigitalRune Graphics supports "texture atlases". I.e. textures can be packed // together into a single, larger texture file. A PackedTexture can describe a // single texture packed into a texture atlas or a tile set packed into a // texture atlas. In this example the "beeWingFlap" is a set of three tiles. // Tile sets can be used for sprite animations. (The animation is set below in // Update().) pose0.Position.X += 2; pose1 = pose0; texture = new PackedTexture("Bee", ContentManager.Load<Texture2D>("Particles/beeWingFlap"), Vector2F.Zero, Vector2F.One, 3, 1); _animatedBillboard = new ImageBillboard(texture); billboardNode = new BillboardNode(_animatedBillboard); billboardNode.Name = "Animated billboards"; billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(_animatedBillboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); pose1.Position.Z -= 1; billboardNode = new BillboardNode(_animatedBillboard); billboardNode.PoseWorld = pose1; _scene.Children.Add(billboardNode); // Use DebugRenderer to draw node names above billboard nodes. foreach (var node in _scene.GetDescendants().OfType<BillboardNode>()) _debugRenderer.DrawText(node.Name, node.PoseWorld.Position + new Vector3F(0, 1, 0), new Vector2F(0.5f), Color.Yellow, false); }
//-------------------------------------------------------------- #region Creation & Cleanup //-------------------------------------------------------------- public DeferredGraphicsScreen(IServiceLocator services) : base(services.GetInstance<IGraphicsService>()) { _sampleFramework = services.GetInstance<SampleFramework>(); var contentManager = services.GetInstance<ContentManager>(); SpriteBatch = GraphicsService.GetSpriteBatch(); // Let's create the necessary scene node renderers: #if !XBOX360 TerrainRenderer = new TerrainRenderer(GraphicsService); #endif MeshRenderer = new MeshRenderer(); // The _opaqueMeshSceneRenderer combines all renderers for opaque // (= not alpha blended) meshes. _opaqueMeshSceneRenderer = new SceneRenderer(); #if !XBOX360 _opaqueMeshSceneRenderer.Renderers.Add(TerrainRenderer); #endif _opaqueMeshSceneRenderer.Renderers.Add(MeshRenderer); _decalRenderer = new DecalRenderer(GraphicsService); _billboardRenderer = new BillboardRenderer(GraphicsService, 2048) { EnableSoftParticles = true, // If you have an extreme amount of particles that cover the entire screen, // you can turn on offscreen rendering to improve performance. //EnableOffscreenRendering = true, }; // The AlphaBlendSceneRenderer combines all renderers for transparent // (= alpha blended) objects. AlphaBlendSceneRenderer = new SceneRenderer(); AlphaBlendSceneRenderer.Renderers.Add(MeshRenderer); AlphaBlendSceneRenderer.Renderers.Add(_billboardRenderer); AlphaBlendSceneRenderer.Renderers.Add(new WaterRenderer(GraphicsService)); AlphaBlendSceneRenderer.Renderers.Add(new FogSphereRenderer(GraphicsService)); AlphaBlendSceneRenderer.Renderers.Add(new VolumetricLightRenderer(GraphicsService)); #if !XBOX360 // Update terrain clipmaps. (Only necessary if TerrainNodes are used.) _terrainClipmapRenderer = new TerrainClipmapRenderer(GraphicsService); #endif // Renderer for cloud maps. (Only necessary if LayeredCloudMaps are used.) _cloudMapRenderer = new CloudMapRenderer(GraphicsService); // Renderer for SceneCaptureNodes. See also SceneCapture2DSample. // In the constructor we specify a method which is called in SceneCaptureRenderer.Render() // when the scene must be rendered for the SceneCaptureNodes. SceneCaptureRenderer = new SceneCaptureRenderer(context => { // Get scene nodes which are visible by the current camera. CustomSceneQuery sceneQuery = Scene.Query<CustomSceneQuery>(context.CameraNode, context); // Render scene (with post-processing, with lens flares, no debug rendering, no reticle). RenderScene(sceneQuery, context, true, true, false, false); }); // Renderer for PlanarReflectionNodes. See also PlanarReflectionSample. // In the constructor we specify a method which is called in PlanarReflectionRenderer.Render() // to create the reflection images. _planarReflectionRenderer = new PlanarReflectionRenderer(context => { // Get scene nodes which are visible by the current camera. CustomSceneQuery sceneQuery = Scene.Query<CustomSceneQuery>(context.CameraNode, context); var planarReflectionNode = (PlanarReflectionNode)context.ReferenceNode; // Planar reflections are often for WaterNodes. These nodes should not be rendered // into their own reflection map because when the water surface is displaced by waves, // some waves could be visible in the reflection. // --> Remove the water node from the renderable nodes. (In our samples, the water // node is the parent of the reflection node.) if (planarReflectionNode.Parent is WaterNode) { var index = sceneQuery.RenderableNodes.IndexOf(planarReflectionNode.Parent); if (index >= 0) sceneQuery.RenderableNodes[index] = null; } // Render scene (no post-processing, no lens flares, no debug rendering, no reticle). RenderScene(sceneQuery, context, false, false, false, false); }); _waterWavesRenderer = new WaterWavesRenderer(GraphicsService); // The shadow map renderer renders a depth image from the viewpoint of the light and // stores it in LightNode.Shadow.ShadowMap. ShadowMapRenderer = new ShadowMapRenderer(context => { var query = context.Scene.Query<ShadowCasterQuery>(context.CameraNode, context); if (query.ShadowCasters.Count == 0) return false; _opaqueMeshSceneRenderer.Render(query.ShadowCasters, context); return true; }); // The shadow mask renderer evaluates the shadow maps, does shadow filtering // and stores the resulting shadow factor in a screen space image //(see LightNode.Shadow.ShadowMask/ShadowMaskChannel). ShadowMaskRenderer = new ShadowMaskRenderer(GraphicsService, 2); // Optionally, we can blur the shadow mask to make the shadows smoother. var blur = new Blur(GraphicsService) { IsAnisotropic = false, IsBilateral = true, EdgeSoftness = 0.05f, Scale = 1f, Enabled = false, // Disable blur by default. }; blur.InitializeGaussianBlur(11, 3, true); ShadowMaskRenderer.Filter = blur; // Renderers which create the intermediate render targets: // Those 2 renderers are implemented in this sample. Those functions could // be implemented directly in this class but we have created separate classes // to make the code more readable. _gBufferRenderer = new GBufferRenderer(GraphicsService, _opaqueMeshSceneRenderer, _decalRenderer); LightBufferRenderer = new LightBufferRenderer(GraphicsService); // Other specialized renderers: _lensFlareRenderer = new LensFlareRenderer(GraphicsService); _skyRenderer = new SkyRenderer(GraphicsService); _fogRenderer = new FogRenderer(GraphicsService); _internalDebugRenderer = new DebugRenderer(GraphicsService, null); _rebuildZBufferRenderer = new RebuildZBufferRenderer(GraphicsService); Scene = new Scene(); // This screen needs a HDR filter to map high dynamic range values back to // low dynamic range (LDR). PostProcessors = new PostProcessorChain(GraphicsService); PostProcessors.Add(new HdrFilter(GraphicsService) { EnableBlueShift = true, BlueShiftCenter = 0.0004f, BlueShiftRange = 0.5f, //BlueShiftColor = new Vector3F(1.05f / 4f, 0.97f / 4f, 1.27f / 4f), // Default physically-based blue-shift BlueShiftColor = new Vector3F(0.25f, 0.25f, 0.7f), // More dramatic blue-shift MinExposure = 0, MaxExposure = 10, BloomIntensity = 1, BloomThreshold = 0.6f, }); _underwaterPostProcessor = new UnderwaterPostProcessor(GraphicsService, contentManager); PostProcessors.Add(_underwaterPostProcessor); // Use 2D texture for reticle. _reticle = contentManager.Load<Texture2D>("Reticle"); // Use the sprite font of the GUI. var uiContentManager = services.GetInstance<ContentManager>("UIContent"); var spriteFont = uiContentManager.Load<SpriteFont>("UI Themes/BlendBlue/Default"); DebugRenderer = new DebugRenderer(GraphicsService, spriteFont) { DefaultColor = new Color(0, 0, 0), DefaultTextPosition = new Vector2F(10), }; EnableLod = true; }
public static void UpdateRenderer(SpriteMeshInstance spriteMeshInstance, bool undo = true) { if (!spriteMeshInstance) { return; } SerializedObject spriteMeshInstaceSO = new SerializedObject(spriteMeshInstance); SpriteMesh spriteMesh = spriteMeshInstaceSO.FindProperty("m_SpriteMesh").objectReferenceValue as SpriteMesh; if (spriteMesh) { Material[] materials = spriteMesh.sharedMaterials; Mesh sharedMesh = spriteMesh.sharedMesh; if (sharedMesh.bindposes.Length > 0 && spriteMeshInstance.bones.Count > sharedMesh.bindposes.Length) { spriteMeshInstance.bones = spriteMeshInstance.bones.GetRange(0, sharedMesh.bindposes.Length); } if (CanEnableSkinning(spriteMeshInstance)) { MeshFilter meshFilter = spriteMeshInstance.cachedMeshFilter; MeshRenderer meshRenderer = spriteMeshInstance.cachedRenderer as MeshRenderer; if (meshFilter) { if (undo) { Undo.DestroyObjectImmediate(meshFilter); } else { GameObject.DestroyImmediate(meshFilter); } } if (meshRenderer) { if (undo) { Undo.DestroyObjectImmediate(meshRenderer); } else { GameObject.DestroyImmediate(meshRenderer); } } SkinnedMeshRenderer skinnedMeshRenderer = spriteMeshInstance.cachedSkinnedRenderer; if (!skinnedMeshRenderer) { if (undo) { skinnedMeshRenderer = Undo.AddComponent <SkinnedMeshRenderer>(spriteMeshInstance.gameObject); } else { skinnedMeshRenderer = spriteMeshInstance.gameObject.AddComponent <SkinnedMeshRenderer>(); } } skinnedMeshRenderer.bones = spriteMeshInstance.bones.ConvertAll(bone => bone.transform).ToArray(); if (spriteMeshInstance.bones.Count > 0) { skinnedMeshRenderer.rootBone = spriteMeshInstance.bones[0].transform; } skinnedMeshRenderer.sharedMaterials = materials; EditorUtility.SetDirty(skinnedMeshRenderer); } else { SkinnedMeshRenderer skinnedMeshRenderer = spriteMeshInstance.cachedSkinnedRenderer; MeshFilter meshFilter = spriteMeshInstance.cachedMeshFilter; MeshRenderer meshRenderer = spriteMeshInstance.cachedRenderer as MeshRenderer; if (skinnedMeshRenderer) { if (undo) { Undo.DestroyObjectImmediate(skinnedMeshRenderer); } else { GameObject.DestroyImmediate(skinnedMeshRenderer); } } if (!meshFilter) { if (undo) { meshFilter = Undo.AddComponent <MeshFilter>(spriteMeshInstance.gameObject); } else { meshFilter = spriteMeshInstance.gameObject.AddComponent <MeshFilter>(); } EditorUtility.SetDirty(meshFilter); } if (!meshRenderer) { if (undo) { meshRenderer = Undo.AddComponent <MeshRenderer>(spriteMeshInstance.gameObject); } else { meshRenderer = spriteMeshInstance.gameObject.AddComponent <MeshRenderer>(); } meshRenderer.sharedMaterials = materials; EditorUtility.SetDirty(meshRenderer); } } } }
protected void CacheReferences() { entityBehaviour = GetComponent <DaggerfallEntityBehaviour>(); entityEffectManager = GetComponent <EntityEffectManager>(); meshRenderer = GetComponentInChildren <MeshRenderer>(); }
public void CreateInstructions() { // spawner.Spawn(); for (int i = 0; i < places.Length; i++) { filledChoice[i] = Random.Range(0, 2); if (filledChoice[i] == 1) { isFilled = false; colorChoice[i] = 4; places[i].SetActive(false); continue; } else if (filledChoice[i] != 1) { isFilled = true; if (pmanger.tutorialNum >= 18) { colorChoice[i] = Random.Range(0, 3); } else { colorChoice[i] = 1; pmanger.tutorialNum++; } switch (colorChoice[i]) { case 0: gameObject.transform.GetChild(i).GetComponent <MeshFilter>().mesh = diamond; break; case 1: gameObject.transform.GetChild(i).GetComponent <MeshFilter>().mesh = sphere; break; case 2: gameObject.transform.GetChild(i).GetComponent <MeshFilter>().mesh = square; break; default: break; } places[i].SetActive(true); } // first = false; filled[i] = isFilled; MeshRenderer mesh = places[i].GetComponent <MeshRenderer>(); TrailRenderer trail = places[i].GetComponent <TrailRenderer>(); switch (colorChoice[i]) { case 0: // Red material mesh.material = managerScript.mats[0]; trail.material = managerScript.mats[0]; break; case 1: // Green material mesh.material = managerScript.mats[1]; trail.material = managerScript.mats[1]; break; case 2: // Blue material mesh.material = managerScript.mats[2]; trail.material = managerScript.mats[2]; break; } EnemyPlacementManager enemyPlace = places[i].GetComponent <EnemyPlacementManager>(); enemyPlace.FillValues(colorChoice[i], i, isFilled); if (isFilled) { // Debug.Log("ok"); spawner.referenceToPlace.Add(places[i]); } } first = false; spawner.Spawn2(); }
/* * public static void CombineMesh(GameObject target) * { * Vector3 position = target.transform.position; * target.transform.position = Vector3.zero; * Dictionary<string, MaterialCombineInstance> combinedMesh = new Dictionary<string, MaterialCombineInstance>(); * MeshFilter[] meshFilters = target.GetComponentsInChildren<MeshFilter>(); * * for (int i = 0; i < meshFilters.Length; i++) * { * if (meshFilters[i].transform != target.transform) * { * MeshFilter currentMeshFilter = meshFilters[i]; * MeshRenderer currentMeshRenderer = currentMeshFilter.GetComponent<MeshRenderer>(); * CombineInstance combine = new CombineInstance(); * string materialName = currentMeshRenderer.material.name.Replace(" (Instance)", ""); * * combine.mesh = currentMeshFilter.mesh; * combine.transform = currentMeshFilter.transform.localToWorldMatrix; * * if (!combinedMesh.ContainsKey(materialName)) * { * combinedMesh.Add(materialName, new MaterialCombineInstance(currentMeshRenderer.material)); * } * combinedMesh[materialName].AddCombineInstance(combine); * currentMeshFilter.gameObject.SetActive(false); * } * } * * Debug.Log(combinedMesh.Keys.Count); * List<CombineInstance> totalMesh = new List<CombineInstance>(); * List<Material> totalMaterial = new List<Material>(); * foreach (KeyValuePair<string, MaterialCombineInstance> kvp in combinedMesh) * { * Mesh newMesh = new Mesh(); * newMesh.CombineMeshes(kvp.Value.m_combineInstances.ToArray()); * CombineInstance combineInstnace = new CombineInstance(); * combineInstnace.mesh = newMesh; * combineInstnace.transform = target.transform.localToWorldMatrix; * totalMesh.Add(combineInstnace); * totalMaterial.Add(kvp.Value.m_material); * } * * Mesh combinedAllMesh = new Mesh(); * combinedAllMesh.CombineMeshes(totalMesh.ToArray(), false); * MeshFilter thisMeshFilter = target.GetComponent<MeshFilter>(); * MeshRenderer thisMeshRenderer = target.GetComponent<MeshRenderer>(); * * thisMeshFilter.mesh = combinedAllMesh; * thisMeshRenderer.materials = totalMaterial.ToArray(); * * target.transform.position = position; * } */ public static void CombineMesh(GameObject target, bool destory = false) { if (target.GetComponent <MeshFilter>() == null) { target.AddComponent <MeshFilter>(); target.AddComponent <MeshRenderer>(); } Vector3 position = target.transform.position; target.transform.position = Vector3.zero; Dictionary <Material, List <CombineInstance> > combinedMesh = new Dictionary <Material, List <CombineInstance> >(); MeshFilter[] meshFilters = target.GetComponentsInChildren <MeshFilter>(); for (int i = meshFilters.Length - 1; i >= 0; i--) { if (meshFilters[i].transform != target.transform) { MeshFilter currentMeshFilter = meshFilters[i]; MeshRenderer currentMeshRenderer = currentMeshFilter.GetComponent <MeshRenderer>(); CombineInstance combine = new CombineInstance(); combine.mesh = currentMeshFilter.sharedMesh; combine.transform = currentMeshFilter.transform.localToWorldMatrix; if (!combinedMesh.ContainsKey(currentMeshRenderer.sharedMaterial)) { combinedMesh.Add(currentMeshRenderer.sharedMaterial, new List <CombineInstance>()); } combinedMesh[currentMeshRenderer.sharedMaterial].Add(combine); if (!destory) { currentMeshFilter.gameObject.SetActive(false); } else { DestroyImmediate(currentMeshFilter.gameObject); } } /* * for (int x = target.transform.childCount-1; x >= 0; x--) * { * * if (target.transform.GetChild(i).GetComponent<MeshRenderer>() == null) * { * DestroyImmediate(target.transform.GetChild(i)); * } * }*/ } List <CombineInstance> totalMesh = new List <CombineInstance>(); List <Material> totalMaterial = new List <Material>(); foreach (KeyValuePair <Material, List <CombineInstance> > kvp in combinedMesh) { Mesh newMesh = new Mesh(); newMesh.CombineMeshes(kvp.Value.ToArray()); CombineInstance combineInstnace = new CombineInstance(); combineInstnace.mesh = newMesh; combineInstnace.transform = target.transform.localToWorldMatrix; totalMesh.Add(combineInstnace); totalMaterial.Add(kvp.Key); } Mesh combinedAllMesh = new Mesh(); combinedAllMesh.CombineMeshes(totalMesh.ToArray(), false); MeshFilter thisMeshFilter = target.GetComponent <MeshFilter>(); MeshRenderer thisMeshRenderer = target.GetComponent <MeshRenderer>(); thisMeshFilter.mesh = combinedAllMesh; thisMeshRenderer.materials = totalMaterial.ToArray(); target.transform.position = position; }
public static void CombineMultipleMesh(GameObject target, bool destory = false) { Vector3 position = target.transform.position; target.transform.position = Vector3.zero; Dictionary <Material, List <CombineInstance> > combinedMesh = new Dictionary <Material, List <CombineInstance> >(); MeshFilter[] meshFilters = target.GetComponentsInChildren <MeshFilter>(); for (int i = meshFilters.Length - 1; i >= 0; i--) { if (meshFilters[i].transform != target.transform) { MeshFilter currentMeshFilter = meshFilters[i]; MeshRenderer currentMeshRenderer = currentMeshFilter.GetComponent <MeshRenderer>(); CombineInstance combine = new CombineInstance(); combine.mesh = currentMeshFilter.sharedMesh; combine.transform = currentMeshFilter.transform.localToWorldMatrix; if (!combinedMesh.ContainsKey(currentMeshRenderer.sharedMaterial)) { combinedMesh.Add(currentMeshRenderer.sharedMaterial, new List <CombineInstance>()); } combinedMesh[currentMeshRenderer.sharedMaterial].Add(combine); if (!destory) { currentMeshFilter.gameObject.SetActive(false); } else { DestroyImmediate(currentMeshFilter.gameObject); } } } Mesh newMesh = new Mesh(); List <Material> totalMaterial = new List <Material>(); int triangleCount = 0; List <CombineInstance> toBeAdded = new List <CombineInstance>(); foreach (KeyValuePair <Material, List <CombineInstance> > kvp in combinedMesh) { List <CombineInstance> ci = kvp.Value; totalMaterial.Add(kvp.Key); for (int i = 0; i < ci.Count; i++) { if (triangleCount + ci[i].mesh.triangles.Length < 65000) { toBeAdded.Add(ci[i]); triangleCount += ci[i].mesh.triangles.Length; } else { Debug.Log(triangleCount); newMesh.CombineMeshes(toBeAdded.ToArray()); GameObject newObject = new GameObject(); newObject.transform.parent = target.transform; newObject.transform.localPosition = Vector3.zero; newObject.transform.localScale = Vector3.one; newObject.transform.localRotation = Quaternion.identity; newObject.AddComponent <MeshFilter>().mesh = newMesh; newObject.AddComponent <MeshRenderer>().materials = totalMaterial.ToArray(); newMesh = new Mesh(); triangleCount = 0; toBeAdded = new List <CombineInstance>(); totalMaterial = new List <Material>(); if (i < ci.Count - 1) { totalMaterial.Add(kvp.Key); } toBeAdded.Add(ci[i]); triangleCount += ci[i].mesh.triangles.Length; } } } /*List<CombineInstance> totalMesh = new List<CombineInstance>(); * List<Material> totalMaterial = new List<Material>(); * foreach (KeyValuePair<Material, List<CombineInstance>> kvp in combinedMesh) * { * Mesh newMesh = new Mesh(); * newMesh.CombineMeshes(kvp.Value.ToArray()); * GameObject child = new GameObject(); * child.transform.parent = target.transform; * child.transform.localScale = Vector3.one; * child.transform.localRotation = Quaternion.identity; * child.AddComponent<MeshFilter>().mesh = newMesh; * child.AddComponent<MeshRenderer>().material = kvp.Key; * } * return; * Mesh combinedAllMesh = new Mesh(); * combinedAllMesh.CombineMeshes(totalMesh.ToArray(), false); * MeshFilter thisMeshFilter = target.GetComponent<MeshFilter>(); * MeshRenderer thisMeshRenderer = target.GetComponent<MeshRenderer>(); * * thisMeshFilter.mesh = combinedAllMesh; * thisMeshRenderer.materials = totalMaterial.ToArray(); * * target.transform.position = position;*/ }
protected virtual void Components() { bulletRb = GetComponent <Rigidbody> (); bulletMeshRender = GetComponent <MeshRenderer> (); bulletCapsuleCollider = GetComponent <CapsuleCollider> (); }
protected override void Awake() { base.Awake(); shieldRenderer = forceFieldGameObject.GetComponent <MeshRenderer>(); }
public MeshNodeSample(Microsoft.Xna.Framework.Game game) : base(game) { SampleFramework.IsMouseVisible = false; var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService) { RenderCallback = Render, }; GraphicsService.Screens.Insert(0, delegateGraphicsScreen); // Add a custom game object which controls the camera. _cameraObject = new CameraObject(Services); GameObjectService.Objects.Add(_cameraObject); // For advanced users: Set this flag if you want to analyze the imported opaque data of // effect bindings. //EffectBinding.KeepOpaqueData = true; // Load a model. The model is processed using the DigitalRune Model Processor - not // the default XNA model processor! // In the folder that contains tank.fbx, there is an XML file tank.drmdl which defines // properties of the model. These XML files are automatically processed by the // DigitalRune Model Processor. // Each model itself is a tree of scene nodes. The grid model contains one mesh // node. The tank model contains several mesh nodes (turret, cannon, hatch, // wheels, ...). _model = ContentManager.Load<ModelNode>("Tank/tank"); // The XNA ContentManager manages a single instance of each model. We clone // the model, to get a copy that we can modify without changing the original // instance. Cloning is fast because it only duplicates the scene nodes - but // not the mesh and material information. _model = _model.Clone(); // _model is the root of a tree of scene nodes. The mesh nodes are the child // nodes. When we scale or move the _model, we automatically scale and move // all child nodes. _model.ScaleLocal = new Vector3F(0.8f); _model.PoseWorld = new Pose(new Vector3F(0, 0, -2), Matrix33F.CreateRotationY(-0.3f)); // Let's loop through the mesh nodes of the model: foreach (var meshNode in _model.GetSubtree().OfType<MeshNode>()) { // Each MeshNode references a Mesh. Mesh mesh = meshNode.Mesh; // The mesh consists of several submeshes and several materials - usually // one material per submesh, but several submeshes could reference the same // materials. // Let's loop through the materials of this mesh. foreach (var material in mesh.Materials) { // A material is a collection of EffectBindings - one EffectBinding for each // render pass. For example, a complex game uses several render passes, like // a pre-Z pass, a G-buffer pass, a shadow map pass, a deferred material pass, // etc.In simple games there is only one pass which is called "Default". var effectBinding = material["Default"]; // An EffectBinding references an Effect (the XNA Effect class) and it has // "parameter bindings" and "technique bindings". These bindings select the // values for the shader parameters when the mesh node is rendered. // Let's change the binding for the DiffuseColor of the shader to give tank // a red color. effectBinding.Set("DiffuseColor", new Vector4(1, 0.7f, 0.7f, 1)); // The tank uses the default effect binding which is a BasicEffectBinding - this // effect binding uses the XNA BasicEffect. // In this sample we do not define any lights, therefore we disable the lighting // in the shader. ((BasicEffectBinding)effectBinding).LightingEnabled = false; } } _meshRenderer = new MeshRenderer(); var spriteFont = UIContentManager.Load<SpriteFont>("UI Themes/BlendBlue/Default"); _debugRenderer = new DebugRenderer(GraphicsService, spriteFont); }
private void Start() { grades = initialGrades; rend = GetComponent <MeshRenderer>(); statusCheck(); }
private readonly LensFlareRenderer _lensFlareRenderer; // Handles LensFlareNodes. public LensFlareSample(Microsoft.Xna.Framework.Game game) : base(game) { SampleFramework.IsMouseVisible = false; var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService) { RenderCallback = Render, }; GraphicsService.Screens.Insert(0, delegateGraphicsScreen); // Add a custom game object which controls the camera. _cameraObject = new CameraObject(Services); GameObjectService.Objects.Add(_cameraObject); // Create a new empty scene. _scene = new Scene(); // Add the camera node to the scene. _scene.Children.Add(_cameraObject.CameraNode); // Add a few models to the scene. var ground = ContentManager.Load<ModelNode>("Ground/Ground").Clone(); _scene.Children.Add(ground); var box = ContentManager.Load<ModelNode>("MetalGrateBox/MetalGrateBox").Clone(); box.PoseLocal = new Pose(new Vector3F(0.5f, 0.5f, 0.5f), Matrix33F.CreateRotationY(0.1f)); _scene.Children.Add(box); // Add some lights to the scene which have the same properties as the lights // of BasicEffect.EnableDefaultLighting(). SceneSample.InitializeDefaultXnaLights(_scene); // Add a lens flare for the sun light. var lensFlare = new LensFlare(true); // The sun is a directional light source. lensFlare.Name = "Sun Flare"; // The Size determines the screen size of the lens flare elements. The value // is relative to the viewport height. lensFlare.Size = 0.28f; // 0.28 * viewport height // The QuerySize of a directional light is the estimated size relative to the // viewport. This value is used in the hardware occlusion query, which determines // whether the lens flare is visible. lensFlare.QuerySize = 0.18f; // 0.18 * viewport height // All lens flare elements are packed into one texture ("texture atlas"). // The PackedTexture identifies an element within the texture atlas. // See file Media/LensFlare/LensFlares.png. // (Credits: The sun lens flare was copied from the XNA racing game - http://exdream.com/XnaRacingGame/.) var lensFlareTexture = ContentManager.Load<Texture2D>("LensFlare/LensFlares"); var circleTexture = new PackedTexture("Circle", lensFlareTexture, new Vector2F(0, 0), new Vector2F(0.25f, 0.5f)); var glowTexture = new PackedTexture("Glow", lensFlareTexture, new Vector2F(0.25f, 0), new Vector2F(0.25f, 0.5f)); var ringTexture = new PackedTexture("Ring", lensFlareTexture, new Vector2F(0.5f, 0), new Vector2F(0.25f, 0.5f)); var haloTexture = new PackedTexture("Halo", lensFlareTexture, new Vector2F(0.75f, 0), new Vector2F(0.25f, 0.5f)); var sunTexture = new PackedTexture("Sun", lensFlareTexture, new Vector2F(0, 0.5f), new Vector2F(0.25f, 0.5f)); var streaksTexture = new PackedTexture("Streaks", lensFlareTexture, new Vector2F(0.25f, 0.5f), new Vector2F(0.25f, 0.5f)); var flareTexture = new PackedTexture("Flare", lensFlareTexture, new Vector2F(0.5f, 0.5f), new Vector2F(0.25f, 0.5f)); // Add a few elements (circles, glow, rings, halos, streaks, ...) to the lens flare. lensFlare.Elements.Add(new LensFlareElement(-0.2f, 0.55f, 0.0f, new Color(175, 175, 255, 20), new Vector2F(0.5f, 0.5f), circleTexture)); lensFlare.Elements.Add(new LensFlareElement(0.0f, 0.9f, 0.0f, new Color(255, 255, 255, 255), new Vector2F(0.5f, 0.5f), sunTexture)); lensFlare.Elements.Add(new LensFlareElement(0.0f, 1.8f, 0.0f, new Color(255, 255, 255, 128), new Vector2F(0.5f, 0.5f), streaksTexture)); lensFlare.Elements.Add(new LensFlareElement(0.0f, 2.6f, 0.0f, new Color(255, 255, 200, 64), new Vector2F(0.5f, 0.5f), glowTexture)); lensFlare.Elements.Add(new LensFlareElement(0.5f, 0.12f, 0.0f, new Color(60, 60, 180, 35), new Vector2F(0.5f, 0.5f), circleTexture)); lensFlare.Elements.Add(new LensFlareElement(0.55f, 0.46f, 0.0f, new Color(100, 100, 200, 60), new Vector2F(0.5f, 0.5f), circleTexture)); lensFlare.Elements.Add(new LensFlareElement(0.6f, 0.17f, 0.0f, new Color(120, 120, 220, 40), new Vector2F(0.5f, 0.5f), circleTexture)); lensFlare.Elements.Add(new LensFlareElement(0.85f, 0.2f, 0.0f, new Color(60, 60, 255, 100), new Vector2F(0.5f, 0.5f), ringTexture)); lensFlare.Elements.Add(new LensFlareElement(1.5f, 0.2f, 0.0f, new Color(255, 60, 60, 130), new Vector2F(0.5f, 0.5f), flareTexture)); lensFlare.Elements.Add(new LensFlareElement(0.15f, 0.15f, 0.0f, new Color(255, 60, 60, 90), new Vector2F(0.5f, 0.5f), flareTexture)); lensFlare.Elements.Add(new LensFlareElement(1.3f, 0.6f, 0.0f, new Color(60, 60, 255, 180), new Vector2F(0.5f, 0.5f), haloTexture)); lensFlare.Elements.Add(new LensFlareElement(1.4f, 0.2f, 0.0f, new Color(220, 80, 80, 98), new Vector2F(0.5f, 0.5f), haloTexture)); lensFlare.Elements.Add(new LensFlareElement(1.5f, 0.1f, 0.0f, new Color(220, 80, 80, 85), new Vector2F(0.5f, 0.5f), circleTexture)); lensFlare.Elements.Add(new LensFlareElement(1.6f, 0.5f, 0.0f, new Color(60, 60, 255, 80), new Vector2F(0.5f, 0.5f), haloTexture)); lensFlare.Elements.Add(new LensFlareElement(1.8f, 0.3f, 0.0f, new Color(90, 60, 255, 110), new Vector2F(0.5f, 0.5f), ringTexture)); lensFlare.Elements.Add(new LensFlareElement(1.95f, 0.5f, 0.0f, new Color(60, 60, 255, 120), new Vector2F(0.5f, 0.5f), haloTexture)); lensFlare.Elements.Add(new LensFlareElement(2.0f, 0.15f, 0.0f, new Color(60, 60, 255, 85), new Vector2F(0.5f, 0.5f), circleTexture)); // The scene node "KeyLight" (defined in SceneSample.InitializeDefaultXnaLights()) // is the main directional light source. var keyLightNode = _scene.GetDescendants().First(n => n.Name == "KeyLight"); // Let's attach the lens flare to the "KeyLight" node. // (Note: It is not necessary to attach a lens flare to a light node. Lens flares // can be added anywhere within the scene. But attaching the lens flare to the // light node ensures that the lens flare always has the same position and direction // as the light source.) var lensFlareNode = new LensFlareNode(lensFlare); keyLightNode.Children = new SceneNodeCollection(); keyLightNode.Children.Add(lensFlareNode); // Add a second lens flare. // The previous lens flare was a caused by a directional light source (distance = infinite). // This time we add a local lens flare. lensFlare = new LensFlare(false); lensFlare.Name = "Anamorphic Flare"; lensFlare.Size = 0.3f; // 0.3 * viewport height // The QuerySize of a local lens flare is estimated size of the light source // in world space. lensFlare.QuerySize = 0.2f; // 0.2 meters // Add some elements (glow, horizontal streaks, ...) to the lens flare effect. var anamorphicFlareTexture = ContentManager.Load<Texture2D>("LensFlare/AnamorphicFlare"); flareTexture = new PackedTexture("AnamorphicFlare", anamorphicFlareTexture, new Vector2F(0, 0), new Vector2F(1.0f, 87f / 256f)); var flare1Texture = new PackedTexture("Flare0", anamorphicFlareTexture, new Vector2F(227f / 512f, 88f / 256f), new Vector2F(285f / 512f, 15f / 256f)); var flare2Texture = new PackedTexture("Flare1", anamorphicFlareTexture, new Vector2F(0, 87f / 256f), new Vector2F(226f / 512f, 168f / 256f)); lensFlare.Elements.Add(new LensFlareElement(0.0f, 0.8f, 0.0f, new Color(255, 255, 255, 255), new Vector2F(0.5f, 0.5f), flareTexture)); lensFlare.Elements.Add(new LensFlareElement(1.0f, new Vector2F(0.6f, 0.5f), 0.0f, new Color(172, 172, 255, 32), new Vector2F(0.5f, 0.5f), flare1Texture)); lensFlare.Elements.Add(new LensFlareElement(1.5f, 1.2f, float.NaN, new Color(200, 200, 255, 24), new Vector2F(0.5f, 0.2f), flare2Texture)); lensFlare.Elements.Add(new LensFlareElement(2.0f, 2.0f, float.NaN, new Color(172, 172, 255, 48), new Vector2F(0.5f, 0.2f), flare2Texture)); // Position the lens flare near the origin. lensFlareNode = new LensFlareNode(lensFlare); lensFlareNode.PoseWorld = new Pose(new Vector3F(-0.5f, 1, 0)); _scene.Children.Add(lensFlareNode); // In this example we need two renderers: // The MeshRenderer handles MeshNodes. _meshRenderer = new MeshRenderer(); // The LensFlareRenderer handles LensFlareNodes. _lensFlareRenderer = new LensFlareRenderer(GraphicsService); }
protected override void OnStart() { meshRenderer = gameObject.GetComponent <MeshRenderer>(); buildingCollider = gameObject.GetComponent <Collider>(); }
/// <summary> /// Construct a new copy of our renderer /// </summary> /// <param name="graphicsDevice"></param> /// <param name="contentManager"></param> /// <param name="width"></param> /// <param name="height"></param> public Renderer(Game game, GraphicsDevice graphicsDevice, ContentManager contentManager, int width, int height) { _width = width; _height = height; _graphicsDevice = graphicsDevice; _contentManager = contentManager; _quadRenderer = new QuadRenderer(); _sphereRenderer = new MeshRenderer(contentManager.Load<Model>("models/sphere")); _spotRenderer = new MeshRenderer(contentManager.Load<Model>("models/cone")); _cwDepthState = new DepthStencilState(); _cwDepthState.DepthBufferWriteEnable = false; _cwDepthState.DepthBufferFunction = CompareFunction.LessEqual; _ccwDepthState = new DepthStencilState(); _ccwDepthState.DepthBufferWriteEnable = false; _ccwDepthState.DepthBufferFunction = CompareFunction.GreaterEqual; _directionalDepthState = new DepthStencilState(); ; _directionalDepthState.DepthBufferWriteEnable = false; _directionalDepthState.DepthBufferFunction = CompareFunction.Greater; _shadowRenderer = new ShadowRenderer(this); CreateGBuffer(); LoadShaders(); _downsampleDepth = new DownsampleDepthEffect(); _downsampleDepth.Init(contentManager, this); }
// Start is called before the first frame update void Start() { mesh = GetComponent<MeshRenderer>(); energyState = GetComponent<EnergyState>(); UpdateMaterial(); }
void Awake() { lights = GetComponentsInChildren <Light>(); meshRenderer = GetComponent <MeshRenderer>(); }
void ResetIt() { mr = GetComponent <MeshRenderer>(); ClearTexture(); }
//bools void Start() { meshRenderer = GetComponent <MeshRenderer>(); rigidBody = GetComponent <Rigidbody>(); boxCollider = GetComponent <BoxCollider>(); }
// Start is called before the first frame update void Awake() { meshRenderer = GetComponent <MeshRenderer>(); }
public Tuple <GameObject, Solid> DrawMesh3D(Vector3 startPoint, Vector3 endPoint, float width, float height, string name) { activeFloor = currentStatusDoma.activeFloor; startPoint = new Vector3(startPoint.x, activeFloor.LevelBottom, startPoint.z); endPoint = new Vector3(endPoint.x, activeFloor.LevelBottom, endPoint.z); float h = height; GameObject gameObject = new GameObject(); gameObject.name = name; var between = endPoint - startPoint; var distance = Vector3.Distance(startPoint, endPoint); Vector3 vNormalized = endPoint - startPoint; Vector3 vPerpendicular = Vector3.Normalize(Vector3.Cross(vNormalized, Vector3.up)); var P1 = startPoint + vPerpendicular * width / 2; var P2 = startPoint - vPerpendicular * width / 2; var P3 = endPoint - vPerpendicular * width / 2; var P4 = endPoint + vPerpendicular * width / 2; Vector3[] vertices = { P1, P2, new Vector3(P2.x,P2.y + h, P2.z), new Vector3(P1.x,P1.y + h, P1.z), new Vector3(P4.x,P4.y + h, P4.z), new Vector3(P3.x,P3.y + h, P3.z), P3, P4, }; Point3d[] points3d = vertices.Select(v => new Point3d(v.x, v.y, v.z)).ToArray(); int[] triangles = { 0, 2, 1, //face front 0, 3, 2, 2, 3, 4, //face top 2, 4, 5, 1, 2, 5, //face right 1, 5, 6, 0, 7, 4, //face left 0, 4, 3, 5, 4, 7, //face back 5, 7, 6, 0, 6, 7, //face bottom 0, 1, 6 }; // UVs dla tekstury Vector2[] uvs = new Vector2[vertices.Length]; for (int i = 0; i < uvs.Length; i++) { uvs[i] = new Vector2(vertices[i].x, vertices[i].y); } var obj = new Net3dBool.Solid(points3d, triangles, getColorArray(8, Color.black)); MeshFilter mf = gameObject.AddComponent <MeshFilter>(); Mesh tmesh = new Mesh(); tmesh.vertices = GetVertices(obj); tmesh.triangles = obj.getIndices(); tmesh.uv = uvs; //tmesh.colors = GetColorsMesh(obj); tmesh.RecalculateNormals(); mf.mesh = tmesh; MeshRenderer mr = gameObject.AddComponent <MeshRenderer>(); gameObject.transform.Translate(new Vector3(2000, 0, 0), Space.World); gameObject.GetComponent <MeshRenderer>().material = material; gameObject.transform.parent = area3D.transform; // Doda Collider gdy ściana ma długość min. 20 cm if (Vector3.Distance(startPoint, endPoint) > 0.2f) { gameObject.AddComponent <MeshCollider>(); } gameObject.tag = "Wall"; gameObject.layer = LayerMask.NameToLayer("3DArea"); return(new Tuple <GameObject, Solid>(gameObject, obj)); }
void Awake() { if (!DaggerfallUnity.Settings.Nystul_RealtimeReflections) { return; } reflectionPlaneBottom = new GameObject("ReflectionPlaneBottom"); reflectionPlaneBottom.layer = LayerMask.NameToLayer("Water"); MeshFilter meshFilter = (MeshFilter)reflectionPlaneBottom.AddComponent(typeof(MeshFilter)); meshFilter.mesh = CreateMesh(100000.0f, 100000.0f); // create quad with normal facing into negative y-direction (so it is not visible but it will trigger OnWillRenderObject() in MirrorReflection.cs) - should be big enough to be "visible" even when looking parallel to the x/z-plane MeshRenderer renderer = reflectionPlaneBottom.AddComponent(typeof(MeshRenderer)) as MeshRenderer; renderer.material.shader = Shader.Find("Standard"); Texture2D tex = new Texture2D(1, 1); tex.SetPixel(0, 0, Color.green); tex.Apply(); renderer.material.mainTexture = tex; renderer.material.color = Color.green; renderer.enabled = true; // if this is set to false OnWillRenderObject() in MirrorReflection.cs will not work (workaround would be to change OnWillRenderObject() to Update() mirrorRefl = reflectionPlaneBottom.AddComponent <MirrorReflection>(); mirrorRefl.m_TextureSize = 512; reflectionPlaneBottom.transform.SetParent(this.transform); InjectReflectiveMaterialProperty scriptInjectReflectiveMaterialProperty = reflectionPlaneBottom.AddComponent <InjectReflectiveMaterialProperty>(); // the inject script is parented to this plane so that the OnWillRenderObject() method of the inject script will work - this is important since update() function resulted in slightly delayed update which could be seen when ground level height changed scriptInjectReflectiveMaterialProperty.iniPathConfigInjectionTextures = this.iniPathConfigInjectionTextures; reflectionPlaneSeaLevel = new GameObject("ReflectionPlaneSeaLevel"); reflectionPlaneSeaLevel.layer = LayerMask.NameToLayer("Water"); MeshFilter meshFilterSeaLevel = (MeshFilter)reflectionPlaneSeaLevel.AddComponent(typeof(MeshFilter)); meshFilterSeaLevel.mesh = CreateMesh(1000000.0f, 1000000.0f); // create quad facing into negative y-direction (so it is not visible but it will trigger OnWillRenderObject() in MirrorReflection.cs) - should be big enough to be "visible" even when looking parallel to the x/z-plane MeshRenderer rendererSeaLevel = reflectionPlaneSeaLevel.AddComponent(typeof(MeshRenderer)) as MeshRenderer; rendererSeaLevel.material.shader = Shader.Find("Standard"); Texture2D texSeaLevel = new Texture2D(1, 1); texSeaLevel.SetPixel(0, 0, Color.green); texSeaLevel.Apply(); rendererSeaLevel.material.mainTexture = texSeaLevel; rendererSeaLevel.material.color = Color.green; rendererSeaLevel.enabled = true; // if this is set to false OnWillRenderObject() in MirrorReflection.cs will not work (workaround would be to change OnWillRenderObject() to Update() mirrorReflSeaLevel = reflectionPlaneSeaLevel.AddComponent <MirrorReflection>(); mirrorReflSeaLevel.m_TextureSize = 512; reflectionPlaneSeaLevel.transform.SetParent(this.transform); LayerMask layerIndexWorldTerrain = LayerMask.NameToLayer("WorldTerrain"); if (layerIndexWorldTerrain != -1) { mirrorRefl.m_ReflectLayers.value = (1 << LayerMask.NameToLayer("Default")) + (1 << LayerMask.NameToLayer("WorldTerrain")); mirrorReflSeaLevel.m_ReflectLayers = (1 << LayerMask.NameToLayer("Default")) + (1 << LayerMask.NameToLayer("WorldTerrain")); } else { mirrorRefl.m_ReflectLayers.value = 1 << LayerMask.NameToLayer("Default"); mirrorReflSeaLevel.m_ReflectLayers = 1 << LayerMask.NameToLayer("Default"); } PlayerEnterExit.OnTransitionInterior += OnTransitionToInterior; PlayerEnterExit.OnTransitionExterior += OnTransitionToExterior; PlayerEnterExit.OnTransitionDungeonInterior += OnTransitionToInterior; PlayerEnterExit.OnTransitionDungeonExterior += OnTransitionToExterior; }
public RefractionMeshRenderer(IGraphicsService graphicsService) { _meshRenderer = new MeshRenderer(); }
void Start() { meshRend = GetComponent <MeshRenderer>(); meshRend.material = defaultMaterial; bCollider = GetComponent <BoxCollider>(); }
private bool DoPaint(bool click) { if (!Painting) { return(false); } Event e = Event.current; GameObject paintOn = null; if (canvas != null) { paintOn = canvas.gameObject; } else { paintOn = Selection.activeGameObject; } if (paintOn == null) { return(false); } MeshRenderer meshRenderer = paintOn.GetComponent <MeshRenderer>(); MeshFilter meshFilter = paintOn.GetComponent <MeshFilter>(); MeshCollider meshCollider = paintOn.GetComponent <MeshCollider>(); if (meshRenderer == null || meshFilter == null || meshCollider == null) { return(false); } Texture2D texture = GetTextureForRenderer(meshRenderer); if (texture == null) { return(false); } IBrush brush = new ScreenCircleBrush(brushColour, brushSize * sceneView.camera.pixelWidth, sceneView.camera, mousePos); if (brushType == 1) { brush = new ScreenRectangleBrush(brushColour, new Vector2(brushSize * sceneView.camera.pixelWidth, brushSize * sceneView.camera.pixelWidth), sceneView.camera, mousePos); } else if (brushType == 2) { brush = new ScreenRectangleBrush(brushColour, new Vector2((brushSize * sceneView.camera.pixelWidth) * 1.5f, (brushSize * sceneView.camera.pixelWidth) * 0.75f), sceneView.camera, mousePos); } else if (brushType == 3) { if (click) { return(false); } brush = new ProjectorRectangleBrush(brushColour, new Vector2(brushSize * 1.5f, brushSize * 0.75f), projector); } if (Painter.Paint(brush, texture, meshCollider)) { return(true); } return(false); }
void Start() { MeshRenderer mr = gameObject.GetComponent <MeshRenderer>(); mr.material = material; }
public static ChiselGeneratedObjects Create(GameObject parentGameObject) { var parentTransform = parentGameObject.transform; // Make sure there's not a dangling container out there from a previous version var existingContainer = parentTransform.FindChildByName(kGeneratedContainerName); ChiselObjectUtility.SafeDestroy(existingContainer, ignoreHierarchyEvents: true); var gameObjectState = GameObjectState.Create(parentGameObject); var container = ChiselObjectUtility.CreateGameObject(kGeneratedContainerName, parentTransform, gameObjectState); var containerTransform = container.transform; var colliderContainer = ChiselObjectUtility.CreateGameObject(kGeneratedMeshColliderName, containerTransform, gameObjectState); Debug.Assert((int)LayerUsageFlags.Renderable == 1); Debug.Assert((int)LayerUsageFlags.CastShadows == 2); Debug.Assert((int)LayerUsageFlags.ReceiveShadows == 4); Debug.Assert((int)LayerUsageFlags.RenderReceiveCastShadows == (1 | 2 | 4)); var renderables = new ChiselRenderObjects[] { new ChiselRenderObjects() { invalid = true }, ChiselRenderObjects.Create(kGeneratedMeshRendererNames[1], containerTransform, gameObjectState, LayerUsageFlags.Renderable), ChiselRenderObjects.Create(kGeneratedMeshRendererNames[2], containerTransform, gameObjectState, LayerUsageFlags.CastShadows), ChiselRenderObjects.Create(kGeneratedMeshRendererNames[3], containerTransform, gameObjectState, LayerUsageFlags.Renderable | LayerUsageFlags.CastShadows), new ChiselRenderObjects() { invalid = true }, ChiselRenderObjects.Create(kGeneratedMeshRendererNames[5], containerTransform, gameObjectState, LayerUsageFlags.Renderable | LayerUsageFlags.ReceiveShadows), new ChiselRenderObjects() { invalid = true }, ChiselRenderObjects.Create(kGeneratedMeshRendererNames[7], containerTransform, gameObjectState, LayerUsageFlags.Renderable | LayerUsageFlags.CastShadows | LayerUsageFlags.ReceiveShadows), }; var meshRenderers = new MeshRenderer[] { renderables[1].meshRenderer, renderables[2].meshRenderer, renderables[3].meshRenderer, renderables[5].meshRenderer, renderables[7].meshRenderer }; renderables[1].invalid = false; renderables[2].invalid = false; renderables[3].invalid = false; renderables[5].invalid = false; renderables[7].invalid = false; var debugHelpers = new ChiselRenderObjects[kDebugHelperCount]; var debugMeshRenderers = new MeshRenderer[kDebugHelperCount]; for (int i = 0; i < kDebugHelperCount; i++) { debugHelpers[i] = ChiselRenderObjects.Create(kGeneratedDebugRendererNames[i], containerTransform, gameObjectState, AssignMeshesJob.kGeneratedDebugRendererFlags[i].Item1, debugHelperRenderer: true); debugMeshRenderers[i] = debugHelpers[0].meshRenderer; debugHelpers[i].invalid = false; } var result = new ChiselGeneratedObjects { generatedDataContainer = container, colliderContainer = colliderContainer, colliders = new ChiselColliderObjects[0], renderables = renderables, meshRenderers = meshRenderers, debugHelpers = debugHelpers, debugMeshRenderers = debugMeshRenderers }; Debug.Assert(IsValid(result)); return(result); }
// Use this for initialization void Start() { // Grab the mesh renderer that's on the same object as this script. meshRenderer = this.gameObject.GetComponentInChildren <MeshRenderer>(); }
public ProjectedShadowSample2(Microsoft.Xna.Framework.Game game) : base(game) { SampleFramework.IsMouseVisible = false; var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService) { RenderCallback = Render, }; GraphicsService.Screens.Insert(0, delegateGraphicsScreen); // The dude model uses a new ProjectedShadowSkinned.fx effect. This effect contains new // parameters 'ShadowMatrix' and 'ShadowColor' which are not yet supported. When an mesh is // loaded via the content manager, effect bindings are automatically created. This is done // by effect interpreters and effect binders. The graphics service uses several predefined // effect interpreter and binder classes to support the most common effect parameters. E.g. // the SceneEffectInterpreter and SceneEffectBinder handle parameters like 'World', 'View', // 'ViewProjection', 'CameraPosition', 'FogColor', etc. (see also class // SceneEffectParameterSemantics). // We can add new effect interpreters/binders or we can add an entry to an existing // interpreter/binder. Let's add entries to the standard SceneEffectInterpreter which creates // meta-data for the new parameters: var sceneEffectInterpreter = GraphicsService.EffectInterpreters.OfType<SceneEffectInterpreter>().First(); sceneEffectInterpreter.ParameterDescriptions.Add( "ShadowMatrix", (parameter, index) => new EffectParameterDescription(parameter, "ShadowMatrix", index, EffectParameterHint.Global)); sceneEffectInterpreter.ParameterDescriptions.Add( "ShadowColor", (parameter, index) => new EffectParameterDescription(parameter, "ShadowColor", index, EffectParameterHint.Global)); // Add entries to the standard SceneEffectBinder which create DelegateParameterBindings for // the new parameters. The delegate bindings use callback methods to compute the parameter // value. var sceneEffectBinder = GraphicsService.EffectBinders.OfType<SceneEffectBinder>().First(); sceneEffectBinder.MatrixBindings.Add( "ShadowMatrix", (effect, parameter, data) => new DelegateParameterBinding<Matrix>(effect, parameter, GetShadowMatrix)); sceneEffectBinder.Vector4Bindings.Add( "ShadowColor", (effect, parameter, data) => new DelegateParameterBinding<Vector4>(effect, parameter, GetShadowColor)); // Create a new empty scene. _scene = new Scene(); Services.Register(typeof(IScene), null, _scene); // Add a custom game object which controls the camera. _cameraObject = new CameraObject(Services); _cameraObject.ResetPose(new Vector3F(-2, 2, 2), -ConstantsF.PiOver4, -0.4f); GameObjectService.Objects.Add(_cameraObject); // Add a default light setup (ambient light + 3 directional lights). var defaultLightsObject = new DefaultLightsObject(Services); GameObjectService.Objects.Add(defaultLightsObject); // Get the main directional light. _mainDirectionalLightNode = ((LightNode)_scene.GetSceneNode("KeyLight")); // Add a ground plane model to the scene graph. var grid = ContentManager.Load<ModelNode>("Ground/Ground").Clone(); grid.ScaleLocal = new Vector3F(0.3f); _scene.Children.Add(grid); // Add a dude model to the scene graph. var dude = ContentManager.Load<ModelNode>("DudeWithProjectedShadow/Dude").Clone(); dude.PoseWorld = new Pose(Matrix33F.CreateRotationY(ConstantsF.Pi)); SampleHelper.EnablePerPixelLighting(dude); _scene.Children.Add(dude); // Start walk animation. StartDudeAnimation(dude); // Create the renderers. _meshRenderer = new MeshRenderer(); _shadowColor = new Vector4(0, 0, 0, 0.4f); }
void Update() { vertices = new Vector3[8]; triangles = new int[18]; vertices[0] = posi1.transform.position; vertices[1] = posi2.transform.position; vertices[2] = posi1_1fbefore; /*posi1.transform.position + Vector3.up * 2;*/ vertices[3] = posi2_1fbefore; /*posi2.transform.position + Vector3.up * 2;*/ vertices[4] = posi1_1fbefore; vertices[5] = posi2_1fbefore; vertices[6] = posi1_2fbefore; vertices[7] = posi2_2fbefore; /* * triangles[0] = 0; * triangles[1] = 1; * triangles[2] = 2; * triangles[3] = 1; * triangles[4] = 3; * triangles[5] = 2; */ for (i2 = 0; i2 < 3; i2++) { for (a = 0; a < 6; a++) { switch (a) { case 0: triangles[i] = i2; break; case 1: triangles[i] = i2 + 1; break; case 2: triangles[i] = i2 + 3 + 1; break; case 3: triangles[i] = i2 + 3 + 1 + 1; break; case 4: triangles[i] = i2 + 3 + 1; break; case 5: triangles[i] = i2 + 1; break; } i++; } } i = 0; Mesh mesh = new Mesh(); mesh.Clear(); mesh.vertices = vertices; mesh.triangles = triangles; mesh.RecalculateNormals(); meshRenderer = GetComponent <MeshRenderer>(); meshFilter = GetComponent <MeshFilter>(); meshFilter.sharedMesh = mesh; if (aaa == Time2) { posi1_2fbefore = posi1_1fbefore; posi2_2fbefore = posi2_1fbefore; aaa = 0; } if (aaa == Time) { posi1_1fbefore = posi1.transform.position; posi2_1fbefore = posi2.transform.position; } /*aaa++;*/ }
public void initialize() { m_MeshFilter = GetComponent<MeshFilter>(); m_MeshRenderer = GetComponent<MeshRenderer>(); }
// Start is called before the first frame update void Awake() { meshRenderer = GetComponent <MeshRenderer>(); original = meshRenderer.material.color; }
// Start(), get the scaled Mesh renderer void Start() { unloadDelay = System.Diagnostics.Stopwatch.Frequency * OnDemandStorage.onDemandUnloadDelay; scaledRenderer = GetComponent<MeshRenderer>(); OnBecameInvisible(); }
void Start() { render = GetComponent <MeshRenderer>(); audioSourse = GetComponent <AudioSource>(); Destroy(gameObject, 75f); }
public SceneSample(Microsoft.Xna.Framework.Game game) : base(game) { SampleFramework.IsMouseVisible = false; var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService) { RenderCallback = Render, }; GraphicsService.Screens.Insert(0, delegateGraphicsScreen); // Add a custom game object which controls the camera. _cameraObject = new CameraObject(Services); GameObjectService.Objects.Add(_cameraObject); // Create a new empty scene. _scene = new Scene(); // Add the camera node to the scene. _scene.Children.Add(_cameraObject.CameraNode); // Load a model. This model uses the DigitalRune Model Processor. Several XML // files (*.drmdl and *.drmat) in the folder of dude.fbx define the materials and other properties. // The DigitalRune Model Processor also imports the animations of the dude model. var model = ContentManager.Load<ModelNode>("Dude/Dude"); // Add two clones of the model to the scene. _model0 = model.Clone(); _model1 = model.Clone(); _scene.Children.Add(_model0); _scene.Children.Add(_model1); // The dude model contains a single mesh node. var meshNode0 = (MeshNode)_model0.Children[0]; var meshNode1 = (MeshNode)_model1.Children[0]; // The imported animation data (skeleton and animations) is stored with the mesh. var animations = meshNode0.Mesh.Animations; // The MeshNodes of skinned models has a SkeletonPose which can be animated. // Let's start the first animation. var timeline0 = new TimelineClip(animations.Values.First()) { LoopBehavior = LoopBehavior.Cycle, // Loop animation... Duration = TimeSpan.MaxValue, // ...forever. }; _animationController0 = AnimationService.StartAnimation(timeline0, (IAnimatableProperty)meshNode0.SkeletonPose); _animationController0.UpdateAndApply(); var timeline1 = new TimelineClip(animations.Values.First()) { LoopBehavior = LoopBehavior.Cycle, Duration = TimeSpan.MaxValue, // Start second animation at a different animation time to add some variety. Delay = TimeSpan.FromSeconds(-1), }; _animationController1 = AnimationService.StartAnimation(timeline1, (IAnimatableProperty)meshNode1.SkeletonPose); _animationController1.UpdateAndApply(); // Add some lights to the scene which have the same properties as the lights // of BasicEffect.EnableDefaultLighting(). InitializeDefaultXnaLights(_scene); _meshRenderer = new MeshRenderer(); var spriteFont = UIContentManager.Load<SpriteFont>("UI Themes/BlendBlue/Default"); _debugRenderer = new DebugRenderer(GraphicsService, spriteFont); }
void Start() { mr = GetComponent <MeshRenderer>(); }
private void Awake() { renderer = this.GetComponent <MeshRenderer>(); }
private void Awake() { rb = GetComponent <Rigidbody>(); meshrenderer = GetComponent <MeshRenderer>(); line = GetComponent <LineRenderer>(); }