示例#1
0
    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),
      };
    }
示例#2
0
        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);
        }
示例#3
0
    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);
    }
示例#4
0
    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 = ...
      };
    }
示例#5
0
        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();
        }
示例#6
0
        //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();
        }
示例#7
0
        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();
        }
示例#8
0
    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"];
    }
示例#9
0
        //--------------------------------------------------------------
        /// <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();
        }
示例#10
0
        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();
        }
示例#11
0
    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();
    }
示例#12
0
    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);
    }
示例#13
0
    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();
    }
示例#14
0
 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);
 }
示例#15
0
        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");
        }
示例#16
0
 void Start()
 {
     RunnerRigidBody = GetComponent <Rigidbody>();
     RunnerRenderer  = GetComponent <MeshRenderer>();
     RunnerCollision = this.GetComponent <BoxCollider>();
 }
示例#17
0
    void Start()
    {
        input = PlayerInput.instance;

        rend = this.GetComponent <MeshRenderer>();
    }
示例#18
0
    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);
    }
示例#19
0
    //--------------------------------------------------------------
    #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;
    }
示例#20
0
        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>();
 }
示例#22
0
    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();
    }
示例#23
0
        /*
         * 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;
        }
示例#24
0
        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> ();
 }
示例#26
0
    protected override void Awake()
    {
        base.Awake();

        shieldRenderer = forceFieldGameObject.GetComponent <MeshRenderer>();
    }
示例#27
0
    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);
    }
示例#28
0
 private void Start()
 {
     grades = initialGrades;
     rend   = GetComponent <MeshRenderer>();
     statusCheck();
 }
示例#29
0
    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);
    }
示例#30
0
 protected override void OnStart()
 {
     meshRenderer     = gameObject.GetComponent <MeshRenderer>();
     buildingCollider = gameObject.GetComponent <Collider>();
 }
示例#31
0
        /// <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();
 }
示例#33
0
 void Awake()
 {
     lights       = GetComponentsInChildren <Light>();
     meshRenderer = GetComponent <MeshRenderer>();
 }
示例#34
0
 void ResetIt()
 {
     mr = GetComponent <MeshRenderer>();
     ClearTexture();
 }
示例#35
0
    //bools

    void Start()
    {
        meshRenderer = GetComponent <MeshRenderer>();
        rigidBody    = GetComponent <Rigidbody>();
        boxCollider  = GetComponent <BoxCollider>();
    }
示例#36
0
 // Start is called before the first frame update
 void Awake()
 {
     meshRenderer = GetComponent <MeshRenderer>();
 }
示例#37
0
    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;
        }
示例#39
0
 public RefractionMeshRenderer(IGraphicsService graphicsService)
 {
   _meshRenderer = new MeshRenderer();
 }
示例#40
0
 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;
    }
示例#43
0
        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);
        }
示例#44
0
 // Use this for initialization
 void Start()
 {
     // Grab the mesh renderer that's on the same object as this script.
     meshRenderer = this.gameObject.GetComponentInChildren <MeshRenderer>();
 }
示例#45
0
    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++;*/
    }
示例#47
0
 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();
 }
示例#50
0
 void Start()
 {
     render      = GetComponent <MeshRenderer>();
     audioSourse = GetComponent <AudioSource>();
     Destroy(gameObject, 75f);
 }
示例#51
0
    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);
    }
示例#52
0
 void Start()
 {
     mr = GetComponent <MeshRenderer>();
 }
示例#53
0
 private void Awake()
 {
     renderer = this.GetComponent <MeshRenderer>();
 }
示例#54
0
 private void Awake()
 {
     rb           = GetComponent <Rigidbody>();
     meshrenderer = GetComponent <MeshRenderer>();
     line         = GetComponent <LineRenderer>();
 }