Example #1
0
        public static Entity CreateEntity(EntityManager entity_manager,
                                          UnityEngine.Vector3 localPos,
                                          UnityEngine.Quaternion localRot,
                                          ref AtomicFloat life,
                                          Entity parent_entity,
                                          ref RandomLocal random)
        {
            var entity = entity_manager.CreateEntity(archetype_);

            entity_manager.SetComponentData(entity, LockTarget.Create(ref life));
            entity_manager.SetComponentData(entity, new Position {
                Value = localPos,
            });
            entity_manager.SetComponentData(entity, new Rotation {
                Value = localRot,
            });
            entity_manager.SetComponentData(entity, random.create());

            var attach_entity = entity_manager.CreateEntity(typeof(Attach));

            entity_manager.SetComponentData(attach_entity, new Attach {
                Parent = parent_entity, Child = entity,
            });

            return(entity);
        }
Example #2
0
        private void init(ref Vector3 position, ref Quaternion rotation, LockTarget lock_target)
        {
            // var rotation = Quaternion.identity;
            base.init(ref position, ref rotation);
            rigidbody_.init();
            rigidbody_.transform_.position_ = position;
            float theta;

            if (MyRandom.Probability(0.5f))
            {
                theta = (MyRandom.Range(-1f, 1f) * Mathf.PI * 0.125f) * Mathf.Rad2Deg;
            }
            else
            {
                theta = (MyRandom.Range(-1f, 1f) * Mathf.PI * 0.125f + Mathf.PI) * Mathf.Rad2Deg;
            }
            var rot = Quaternion.Euler(0f, 0f, theta) * rotation;
            var v   = rot * new Vector3(20f, 0f, 0f);

            rigidbody_.setVelocity(ref v);
            lock_target_   = lock_target;
            trail_locator_ = new Vector3(0, 0, -1);
            // var col = new Color(0.1f, 1f, 0.5f);
            var pos = rigidbody_.transform_.transformPosition(ref trail_locator_);

            trail_id_ = Trail.Instance.spawn(ref pos,
                                             0.2f /* width */,
                                             Trail.Type.Missile);
            arrival_time_  = MyRandom.Range(1.0f, 1.5f);
            destroy_start_ = 0f;
        }
Example #3
0
        void Update()
        {
            player_.rigidbody_.transform_.position_ = camera_.transform.position;
            player_.rigidbody_.transform_.rotation_ = camera_.transform.rotation;
            foreach (var t in list_)
            {
                t.update(1f / 60f, Time.time, 0f /* flow_speed */);
            }
            LockTarget.checkAll(player_, Time.time);

            var inv_mat = player_.rigidbody_.transform_.getInverseR();

            foreach (var t in list_)
            {
                if (t.lock_target_.isEntering(ref inv_mat,
                                              ref player_.rigidbody_.transform_.position_,
                                              1f /* ratio */,
                                              1f /* dist_min */,
                                              500f /* dist_max */))
                {
                    t.owner_.GetComponent <MeshRenderer>().material.color = Color.red;
                }
                else
                {
                    t.owner_.GetComponent <MeshRenderer>().material.color = Color.white;
                }
            }
        }
Example #4
0
        void Update()
        {
            my_camera_.rigidbody_.transform_.position_ = camera_.transform.position;
            my_camera_.rigidbody_.transform_.rotation_ = camera_.transform.rotation;
            foreach (var t in list_)
            {
                t.update(1f / 60f, Time.time);
                // t.renderUpdate(0 /* front */, my_camera_, ref dummy_draw_buffer_);
            }
            LockTarget.checkAll(my_camera_);

            var inv_mat = my_camera_.rigidbody_.transform_.getInverseR();

            foreach (var t in list_)
            {
                if (t.lock_target_.isEntering(ref inv_mat,
                                              ref my_camera_.rigidbody_.transform_.position_,
                                              1f /* ratio */,
                                              1f /* dist_min */,
                                              500f /* dist_max */))
                {
                    t.owner_.GetComponent <MeshRenderer>().material.color = Color.red;
                }
                else
                {
                    t.owner_.GetComponent <MeshRenderer>().material.color = Color.white;
                }
            }
        }
            public void Execute(int i)
            {
                LockTarget lt = locktarget_list_[i];

                if (lt.isLocked(time_))
                {
                    lockon_limit_.TryIncrement(LASER_MAX);
                }
            }
Example #6
0
 public override void destroy()
 {
     // type_ = Type.None;
     enumerator_ = null;
     lock_target_.destroy();
     lock_target_ = null;
     MyCollider.destroyEnemy(collider_);
     base.destroy();
 }
Example #7
0
 public static void createPool()
 {
     pool_ = new LockTarget[POOL_MAX];
     for (var i = 0; i < POOL_MAX; ++i)
     {
         var obj = new LockTarget();
         obj.alive_ = false;
         pool_[i]   = obj;
     }
     pool_index_ = 0;
 }
Example #8
0
 public void zako2_init(ref Vector3 position, ref Quaternion rotation)
 {
     rigidbody_.init(ref position, ref rotation);
     collider_ = MyCollider.createEnemy();
     MyCollider.initSphereEnemy(collider_, ref position, 1f /* radius */);
     lock_target_      = LockTarget.create(this, new LockTarget.CalcPosition(calc_lock_position_center));
     enumerator_       = zako2_act(); // この瞬間は実行されない
     on_update_        = new OnUpdateFunc(zako2_update);
     on_render_update_ = new OnRenderUpdateFunc(zako2_render_update);
     life_             = 100f;
 }
Example #9
0
        public void renderUpdate(int front)
        {
            MySprite.Instance.put(front, ref location_rect_, MySprite.Kind.Location, MySprite.Type.Half);
            MySprite.Instance.put(front, ref maxlockon_rect_, MySprite.Kind.MaxLockon, MySprite.Type.Half);

            // lockon gauge
            int lock_num   = LockTarget.getCurrentLockNum();
            int fired_num  = LockTarget.getCurrentFiredNum();
            int charge_num = lock_num - fired_num;
            int idx        = 0;

            for (var i = 0; i < gauge_rect_L_list_.Length; ++i)
            {
                MySprite.Kind kind = (idx < charge_num ? MySprite.Kind.GaugeRL : MySprite.Kind.GaugeBL);
                MySprite.Instance.put(front, ref gauge_rect_L_list_[i], kind, MySprite.Type.Half);
                ++idx;
            }
            for (var i = 0; i < gauge_rect_M_list_.Length; ++i)
            {
                MySprite.Kind kind = (idx < charge_num ? MySprite.Kind.GaugeRM : MySprite.Kind.GaugeBM);
                MySprite.Instance.put(front, ref gauge_rect_M_list_[i], kind, MySprite.Type.Half);
                ++idx;
            }
            for (var i = 0; i < gauge_rect_S_list_.Length; ++i)
            {
                MySprite.Kind kind = (idx < charge_num ? MySprite.Kind.GaugeRS : MySprite.Kind.GaugeBS);
                MySprite.Instance.put(front, ref gauge_rect_S_list_[i], kind, MySprite.Type.Half);
                ++idx;
            }

            // unitychan
            if (unitychan_width_ratio_ > 0f)
            {
                var rect = new Rect(unitychan_rect_.x,
                                    unitychan_rect_.y,
                                    unitychan_rect_.width * unitychan_width_ratio_,
                                    unitychan_rect_.height * unitychan_height_ratio_);
                MySprite.Instance.put(front, ref rect, unitychan_kind_, MySprite.Type.Full);
            }

            // weapon & damage
            MySprite.Instance.put(front, ref weapon_rect_, MySprite.Kind.Weapon, MySprite.Type.Half);
            if (damage_mark_on_)
            {
                var rect = weapon_rect_;
                rect.x     += damage_mark_position_.x;
                rect.y     += damage_mark_position_.y;
                rect.width  = 32f;
                rect.height = 32f;
                MySprite.Instance.put(front, ref rect, MySprite.Kind.DamageMark, MySprite.Type.GuardMark);
            }
        }
Example #10
0
        public void spawn_internal(EntityCommandBuffer.Concurrent command_buffer,
                                   ref LockTarget lt,
                                   ref float3 position,
                                   ref quaternion rotation,
                                   ref RandomLocal random,
                                   int index,
                                   Entity target,
                                   float arrive_period,
                                   int job_index)
        {
            command_buffer.CreateEntity(job_index, archetype_);
            command_buffer.SetComponent(job_index, new Position {
                Value = position,
            });
            command_buffer.SetComponent(job_index, new LaserData {
                end_time_      = CV.MaxValue,
                target_entity_ = target,
                arrive_period_ = arrive_period,
                lock_target_   = lt,
            });
            var         rb            = new RigidbodyPosition(0f /* damper */);
            const float FIRE_VEL      = 8f;
            var         fire_velocity = new float3(index % 2 == 0 ? FIRE_VEL * 2f : -FIRE_VEL * 2f,
                                                   random.range(-FIRE_VEL, FIRE_VEL),
                                                   random.range(-FIRE_VEL, FIRE_VEL));

            rb.velocity_ = math.mul(rotation, fire_velocity);
            command_buffer.SetComponent(job_index, rb);
            var td = new TrailData {
                color_type_ = (int)TrailManager.ColorType.Green,
            };

            command_buffer.SetComponent(job_index, td);

            {
                var buffer = command_buffer.SetBuffer <TrailPoint>(job_index);
                for (var i = 0; i < buffer.Capacity; ++i)
                {
                    buffer.Add(new TrailPoint {
                        position_ = position, normal_ = new float3(0f, 0f, 1f),
                    });
                }
            }

            var material = TrailManager.Instance.getMaterial();
            var renderer = new TrailRenderer {
                material_ = material,
            };

            command_buffer.SetSharedComponent <TrailRenderer>(job_index, renderer);
        }
Example #11
0
 public void restart()
 {
     GameManager.Instance.restart();
     TaskManager.Instance.restart();
     MyCollider.restart();
     LockTarget.restart();
     TubeScroller.Instance.restart();
     Beam.Instance.restart();
     Trail.Instance.restart();
     Sight.Instance.restart();
     setBulletTime(false);
     flow_speed_target_ = 0f;
     flow_speed_        = 0f;
 }
Example #12
0
        public void dragon_init()
        {
            var position = new Vector3(-10f, -5f, 10f);

            rigidbody_.init(ref position, ref CV.QuaternionIdentity);
            rigidbody_.setDamper(2f);
            rigidbody_.setRotateDamper(20f);
            collider_ = MyCollider.createEnemy();
            MyCollider.initSphereEnemy(collider_, ref position, 1f /* radius */);
            lock_target_      = LockTarget.create(this, new LockTarget.CalcPosition(calc_lock_position_dragon));
            enumerator_       = dragon_act(); // この瞬間は実行されない
            on_update_        = new OnUpdateFunc(dragon_update);
            on_render_update_ = new OnRenderUpdateFunc(dragon_render_update);
            life_             = 10000000f;
            dragon_           = dragon_pool_;
            dragon_.init(this, ref rigidbody_.transform_.position_, ref rigidbody_.transform_.rotation_);
        }
Example #13
0
 public void init(Task task,
                  int idx,
                  ref Vector3 position,
                  ref Quaternion rotation,
                  DrawBuffer.Type draw_type)
 {
     rigidbody_.init(ref position, ref rotation);
     rigidbody_.setRotateDamper(8);
     collider_ = MyCollider.createEnemy();
     MyCollider.initSphereEnemy(collider_, ref position, 1f /* radius */);
     idx_         = idx;
     lock_target_ = LockTarget.create(task, new LockTarget.CalcPosition(this.calc_lock_position));
     locator_     = (idx_ == 0 ?
                     new Vector3(0f, 0f, 0f) :
                     new Vector3(0f, 0f, -3f));
     draw_type_ = draw_type;
 }
 void spawn(ref LockTarget lt,
            ref float3 pos,
            ref quaternion rot,
            ref RandomLocal random,
            int i,
            Entity entity,
            float arrive_period)
 {
     ECSLaserManager.spawn(command_buffer_,
                           ref lt,
                           ref pos,
                           ref rot,
                           ref random,
                           i,
                           entity,
                           arrive_period);
 }
 public static void spawn(EntityCommandBuffer.Concurrent command_buffer,
                          ref LockTarget lt,
                          ref float3 position,
                          ref quaternion rotation,
                          ref RandomLocal random,
                          int index,
                          Entity target,
                          float arrive_period)
 {
     Instance.spawn_internal(command_buffer,
                             ref lt,
                             ref position,
                             ref rotation,
                             ref random,
                             index,
                             target,
                             arrive_period);
 }
            public void Execute(int i)
            {
                LockTarget lt = locktarget_list_[i];

                if (!lt.isLocked(time_))
                {
                    bool  can_lock = false;
                    var   locktarget_local_to_world = locktarget_local_to_world_list_[i].Value;
                    var   diff          = locktarget_local_to_world.c3.xyz - player_position_.Value;
                    float inner_product = math.dot(diff, player_normal_);
                    if (inner_product > 0f)
                    {
                        float diffsqr = Vector3.Dot(diff, diff);
                        if (inner_product * inner_product >= diffsqr * cone_cos_sqr_)
                        {
                            if (lt.has_direction_ != 0)
                            {
                                var fwd = new float4(0f, 0f, 1f, 0f);
                                var vec = math.mul(locktarget_local_to_world, fwd).xyz;
                                if (math.dot(diff, vec) < 0f)
                                {
                                    can_lock = true;
                                }
                            }
                            else
                            {
                                can_lock = true;
                            }
                        }
                    }
                    if (can_lock)
                    {
                        if (lockon_limit_.TryIncrement(LASER_MAX /* inclusive_limit */))
                        {
                            lt.setLocked(time_);
                            locktarget_list_[i] = lt;
                            sight_spawner_.Enqueue(new SightSpawnData {
                                target_entity_ = locktarget_entity_list_[i],
                            });
                        }
                    }
                }
            }
Example #17
0
        private void update_attack(double update_time, bool replay)
        {
            if (!replay)
            {
                fire_button_ = getButton(InputManager.Button.Fire) > 0;
            }
            bool fire_button_released = (!fire_button_ && prev_fire_button_);

            prev_fire_button_ = fire_button_;

            // fire bullets
            if (fire_button_)
            {
                if (can_fire_time_ - update_time > 0f && update_time - fire_time_ > 0f)
                {
                    var lpos = rigidbody_.transform_.transformPosition(ref l_bullet_locator_);
                    Bullet.create(ref lpos, ref rigidbody_.transform_.rotation_, 120f /* speed */, update_time);
                    var rpos = rigidbody_.transform_.transformPosition(ref r_bullet_locator_);
                    Bullet.create(ref rpos, ref rigidbody_.transform_.rotation_, 120f /* speed */, update_time);
                    SystemManager.Instance.registSound(DrawBuffer.SE.Bullet);
                    fire_time_  = update_time + 0.08f;
                    arm_offset_ = 1f;
                }
            }
            else
            {
                can_fire_time_ = update_time + 2f;
            }

            // lockonrange display
            LockonRange.Instance.setOn(fire_button_);
            now_locking_ = fire_button_;

            // fire missiles
            if (fire_button_released)
            {
                bool fired = LockTarget.fireMissiles(this);
                if (fired)
                {
                    SystemManager.Instance.registSound(DrawBuffer.SE.Missile);
                }
            }
        }
Example #18
0
            public void Execute(int i)
            {
                LockTarget lt = locktarget_list_[i];

                if (lt.isLocked(time_))
                {
                    var screen_pos = screen_position_list_[i];
                    var spd        = new SpriteData();
                    spd.setType(SpriteManager.Type.target);
                    spd.setPosition(ref screen_pos.Value);
                    if (lt.isFired(time_))
                    {
                        spd.setColor(1f, 0.25f, 0.2f, 1f);
                    }
                    else
                    {
                        spd.setColor(0.1f, 1f, 0.5f, 1f);
                    }
                    sprite_data_list_.AddRef(ref spd);
                }
            }
Example #19
0
        void Start()
        {
            TaskManager.Instance.init();
            // Sight.Instance.init();
            LockTarget.createPool();
            list_ = new List <TestTask>();
            GameObject prefab = null;

            for (var i = 0; i < MAX; ++i)
            {
                GameObject go;
                if (prefab == null)
                {
                    prefab = GameObject.Find("Cube");
                    go     = prefab;
                }
                else
                {
                    float range = 8;
                    go = Instantiate(prefab, new Vector3(Random.Range(-range, range),
                                                         Random.Range(-range, range),
                                                         Random.Range(-range, range)),
                                     Quaternion.identity) as GameObject;
                }
                var task = new TestTask();
                var pos  = go.transform.position;
                var rot  = go.transform.rotation;
                task.init();
                task.rigidbody_.init(ref pos, ref rot);
                var lock_target = LockTarget.create(task, new LockTarget.CalcPosition(task.calc_position));
                task.lock_target_ = lock_target;
                task.owner_       = go;
                list_.Add(task);
            }
            camera_ = Camera.main;

            player_ = Player.create();
        }
Example #20
0
        // private DrawBuffer dummy_draw_buffer_;

        void Start()
        {
            TaskManager.Instance.init();
            Sight.Instance.init(null /* material */);
            LockTarget.createPool();
            list_ = new List <TestTask>();
            GameObject prefab = null;

            for (var i = 0; i < MAX; ++i)
            {
                GameObject go;
                if (prefab == null)
                {
                    prefab = GameObject.Find("Cube");
                    go     = prefab;
                }
                else
                {
                    float range = 8;
                    go = Instantiate(prefab, new Vector3(Random.Range(-range, range),
                                                         Random.Range(-range, range),
                                                         Random.Range(-range, range)),
                                     Quaternion.identity) as GameObject;
                }
                var task = new TestTask();
                var pos  = go.transform.position;
                var rot  = go.transform.rotation;
                task.init(ref pos, ref rot);
                var lock_target = LockTarget.create(task, ref CV.Vector3Zero);
                task.lock_target_ = lock_target;
                task.owner_       = go;
                list_.Add(task);
            }
            camera_ = Camera.main;

            my_camera_ = MyCamera.create();
            // dummy_draw_buffer_ = new DrawBuffer();
        }
Example #21
0
        public void init(ref Vector3 position, ref Quaternion rotation, Type type)
        {
            base.init(ref position, ref rotation);
            collider_ = MyCollider.createEnemy();
            MyCollider.initSphereEnemy(collider_, ref position, 1f /* radius */);
            var lock_pos = new Vector3(0, 0, 0);

            lock_target_ = LockTarget.create(this, ref lock_pos);

            type_  = type;
            phase_ = Phase.Alive;
            switch (type_)
            {
            case Type.None:
                Debug.Assert(false);
                break;

            case Type.Zako:
                /* ここで GC.allocate が発生してしまう */
                enumerator_ = zako_act();                 // この瞬間は実行されない
                break;
            }
        }
Example #22
0
        public static Missile create(ref Vector3 position, ref Quaternion rotation, LockTarget lock_target)
        {
            int cnt = 0;

            while (pool_[pool_index_].alive_)
            {
                ++pool_index_;
                if (pool_index_ >= POOL_MAX)
                {
                    pool_index_ = 0;
                }
                ++cnt;
                if (cnt >= POOL_MAX)
                {
                    Debug.LogError("EXCEED Missile POOL!");
                    break;
                }
            }
            var obj = pool_[pool_index_];

            obj.init(ref position, ref rotation, lock_target);
            return(obj);
        }
Example #23
0
        public override void update(float dt, float update_time)
        {
            update_time_ = update_time;

            if (MyCollider.getHitOpponentForPlayer(collider_) != MyCollider.Type.None)
            {
                var pos = new Vector3(MyRandom.Range(-2f, 2f),
                                      MyRandom.Range(-2f, 2f),
                                      MyRandom.Range(-2f, 2f));
                HUD.Instance.setDamagePoint(ref pos);
            }

            if (Options.Instance.AutoPlay)
            {
                enumerator_.MoveNext();
            }

            int  hori        = getButton(InputManager.Button.Horizontal);
            int  vert        = getButton(InputManager.Button.Vertical);
            bool fire_button = getButton(InputManager.Button.Fire) > 0;
            int  lr          = getButton(InputManager.Button.Roll);

            roll_target_ += (float)(lr) * 150f * dt;
            roll_         = Mathf.Lerp(roll_, roll_target_, 0.1f);
            const float MOVE_FORCE   = 1f;
            const float CURSOR_FORCE = 6f;

            float sn = Mathf.Sin(roll_ * Mathf.Deg2Rad);
            float cs = Mathf.Cos(roll_ * Mathf.Deg2Rad);
            float vx = hori * cs - vert * sn;
            float vy = hori * sn + vert * cs;

            rigidbody_.addForceXY(vx * MOVE_FORCE, vy * MOVE_FORCE);
            target_cursor_.addForceXY(vx * CURSOR_FORCE, vy * CURSOR_FORCE);

            if (hori < 0)
            {
                pitch_acceleration_ += 2000f;
            }
            else if (hori > 0)
            {
                pitch_acceleration_ += -2000f;
            }

            // cursor update
            {
                // 外に向けさせない
                float x    = rigidbody_.transform_.position_.x + target_cursor_.transform_.position_.x;
                float y    = rigidbody_.transform_.position_.y + target_cursor_.transform_.position_.y;
                float len2 = x * x + y * y;
                float R    = 64f;
                if (len2 > Tube.RADIUS_SQR)
                {
                    R = 256f;
                }
                target_cursor_.addForceX(-target_cursor_.transform_.position_.x * R);
                target_cursor_.addForceY(-target_cursor_.transform_.position_.y * R);
                target_cursor_.update(dt);
            }

            // pitch
            pitch_acceleration_ += -pitch_ * 8f;          // spring
            pitch_acceleration_ += -pitch_velocity_ * 4f; // friction
            pitch_velocity_     += pitch_acceleration_ * dt;
            pitch_ += pitch_velocity_ * dt;
            pitch_acceleration_ = 0f;

            // rotate
            rigidbody_.transform_.rotation_ = Quaternion.LookRotation(target_cursor_.transform_.position_) * Quaternion.Euler(0, 0, pitch_);

            // update
            rigidbody_.update(dt);
            float radius = Tube.RADIUS - PLAYER_WIDTH2;

            if (rigidbody_.transform_.position_.sqrMagnitude >= radius * radius)
            {
                hit_wall_ = true;
                rigidbody_.cancelUpdateForTube(dt);
                if (MyRandom.ProbabilityForSecond(60f, SystemManager.Instance.getDT()))
                {
                    float x    = rigidbody_.transform_.position_.x;
                    float y    = rigidbody_.transform_.position_.y;
                    float z    = rigidbody_.transform_.position_.z;
                    float len  = Mathf.Sqrt(x * x + y * y);
                    float rlen = 1f / len;
                    float r    = rlen * Tube.RADIUS;
                    var   v    = new Vector3(x * r, y * r, z);
                    Spark.Instance.spawn(ref v, Spark.Type.Orange, update_time);
                }
            }
            else
            {
                hit_wall_ = false;
            }

            // collider
            MyCollider.updatePlayer(collider_, ref rigidbody_.transform_.position_);

            // fire bullets
            if (fire_button && update_time - fire_time_ > 0.06667f)
            {
                var lpos = rigidbody_.transform_.transformPosition(ref l_bullet_locator_);
                Bullet.create(ref lpos, ref rigidbody_.transform_.rotation_, 120f /* speed */, update_time);
                var rpos = rigidbody_.transform_.transformPosition(ref r_bullet_locator_);
                Bullet.create(ref rpos, ref rigidbody_.transform_.rotation_, 120f /* speed */, update_time);
                SystemManager.Instance.registSound(DrawBuffer.SE.Bullet);
                fire_time_ = update_time;
            }

            // fire missiles
            if (fire_button && !prev_fire_button_)                              // tmp
            {
                bool fired = LockTarget.fireMissiles(this);
                if (fired)
                {
                    SystemManager.Instance.registSound(DrawBuffer.SE.Missile);
                }
            }
            prev_fire_button_ = fire_button;

            // trail
            {
                float flow_z = -30f * dt;
                var   lpos   = rigidbody_.transform_.transformPosition(ref l_trail_locator_);
                Trail.Instance.update(l_trail_, ref lpos, flow_z, update_time);
                var rpos = rigidbody_.transform_.transformPosition(ref r_trail_locator_);
                Trail.Instance.update(r_trail_, ref rpos, flow_z, update_time);
            }
        }
Example #24
0
        private void main_loop()
        {
            long begin_time = stopwatch_.ElapsedTicks;

            // flip
            int updating_front = 1 - rendering_front_;

            // begin
            Sight.Instance.begin();
            MySprite.Instance.begin();
            MyFont.Instance.begin();
            Beam.Instance.begin(updating_front);
            Trail.Instance.begin(updating_front);
            Spark.Instance.begin();
            Explosion.Instance.begin();
            Hahen.Instance.begin();

            // update
            bool locked = false;

            if (!pause_)
            {
                GameManager.Instance.update(dt_, update_time_);
                TaskManager.Instance.update(dt_, update_time_);
                // lockon
                locked = LockTarget.checkAll(player_);
                Sight.Instance.updateAll(dt_);
                // HUD
                HUD.Instance.update(dt_, update_time_);
                // collision
                MyCollider.calculate();

                if (InputManager.Instance.getButton(InputManager.Button.Pause) > 0)
                {
                    pause_ = true;
                }
                ++update_frame_;
                update_time_ += dt_;
            }
            else
            {
                if (InputManager.Instance.getButton(InputManager.Button.Pause) > 0)
                {
                    pause_ = false;
                }
            }
            if (locked)
            {
                registSound(DrawBuffer.SE.Lockon);
            }
            update_tick_ = stopwatch_.ElapsedTicks - begin_time;
            begin_time   = stopwatch_.ElapsedTicks;

            // renderUpdate
            draw_buffer_[updating_front].beginRender();
            TaskManager.Instance.renderUpdate(updating_front, ref draw_buffer_[updating_front]);

            // HUD
            HUD.Instance.renderUpdate(updating_front);

            render_update_tick_ = stopwatch_.ElapsedTicks - begin_time;
            // debug info
            if (Options.Instance.PerformanceMeter)
            {
                {
                    MyFont.Instance.putNumber(updating_front, (int)update_frame_, 8 /* keta */, 0.5f /* scale */,
                                              -440f, 270f, MyFont.Type.Green);
                }
                {
                    int gc_count = System.GC.CollectionCount(0 /* generation */) - gc_start_count_;
                    MyFont.Instance.putNumber(updating_front, gc_count, 8 /* keta */, 0.5f /* scale */,
                                              -440f, 254f, MyFont.Type.Red);
                }
                if (used_heap_size_ != 0)
                {
                    int bytes = (int)used_heap_size_;
                    MyFont.Instance.putNumber(updating_front, bytes, 9 /* keta */, 0.5f /* scale */,
                                              -340f, 254f, MyFont.Type.Red);
                }
                if (mono_heap_size_ != 0)
                {
                    int bytes = (int)mono_heap_size_;
                    MyFont.Instance.putNumber(updating_front, bytes, 9 /* keta */, 0.5f /* scale */,
                                              -240f, 254f, MyFont.Type.Red);
                }
                if (mono_used_size_ != 0)
                {
                    int bytes = (int)mono_used_size_;
                    MyFont.Instance.putNumber(updating_front, bytes, 9 /* keta */, 0.5f /* scale */,
                                              -140f, 254f, MyFont.Type.Red);
                }
                {
                    int task_count = TaskManager.Instance.getCount();
                    MyFont.Instance.putNumber(updating_front, task_count, 8 /* keta */, 0.5f /* scale */,
                                              -440f, 238f, MyFont.Type.Blue);
                }

                var height   = 5f;
                var length   = 440f;
                var badget   = 16.666f;
                var update_y = 262f;
                var render_y = 254f;
                {
                    var rect0b = new Rect(-length * 0.5f, update_y, length, height);
                    MySprite.Instance.put(updating_front, ref rect0b, MySprite.Kind.Square, MySprite.Type.Black);

                    var update_ratio = (float)update_tick_ * 1000f / ((float)System.Diagnostics.Stopwatch.Frequency * badget);
                    var rect1b       = new Rect(length * (update_ratio * 0.5f - 1f), update_y,
                                                length * update_ratio, height);
                    MySprite.Instance.put(updating_front, ref rect1b, MySprite.Kind.Square, MySprite.Type.Blue);

                    var render_update_ratio = (float)render_update_tick_ * 1000f / ((float)System.Diagnostics.Stopwatch.Frequency * badget);
                    var rect2b = new Rect(length * (update_ratio - 1f + render_update_ratio * 0.5f), update_y,
                                          length * update_ratio, height);
                    MySprite.Instance.put(updating_front, ref rect2b, MySprite.Kind.Square, MySprite.Type.Green);
                }
#if UNITY_PSP2 || UNITY_PS4
                {
                    var render_ratio = (float)render_tick_ * 1000f / ((float)System.Diagnostics.Stopwatch.Frequency * badget);
                    var rect0b       = new Rect(-length * 0.5f, render_y, length, height);
                    MySprite.Instance.put(updating_front, ref rect0b, MySprite.Kind.Square, MySprite.Type.Black);
                    var rect1b = new Rect(length * (render_ratio * 0.5f - 1f), render_y, length * render_ratio, height);
                    MySprite.Instance.put(updating_front, ref rect1b, MySprite.Kind.Square, MySprite.Type.Red);

                    var render_ratio_begin = (float)render_tick3_ * 1000f / ((float)System.Diagnostics.Stopwatch.Frequency * badget);
                    var render_ratio_end   = (float)render_tick4_ * 1000f / ((float)System.Diagnostics.Stopwatch.Frequency * badget);
                    var render_ratio_len   = render_ratio_end - render_ratio_begin;
                    var rect2b             = new Rect(length * (render_ratio_len * 0.5f - 1f + render_ratio_begin * 0.5f), render_y,
                                                      length * (render_ratio_len), height);
                    MySprite.Instance.put(updating_front, ref rect2b, MySprite.Kind.Square, MySprite.Type.Magenta);
                }
#else
                {
                    var render_ratio = (float)render_tick2_ * 1000f / ((float)System.Diagnostics.Stopwatch.Frequency * badget);
                    var rect0b       = new Rect(-length * 0.5f, render_y, length, height);
                    MySprite.Instance.put(updating_front, ref rect0b, MySprite.Kind.Square, MySprite.Type.Black);
                    var rect1b = new Rect(length * (render_ratio * 0.5f - 1f), render_y, length * render_ratio, height);
                    MySprite.Instance.put(updating_front, ref rect1b, MySprite.Kind.Square, MySprite.Type.Red);
                }
#endif
            }

            // end
            Hahen.Instance.end(updating_front);
            Explosion.Instance.end(updating_front);
            Spark.Instance.end(updating_front);
            Trail.Instance.end();
            Beam.Instance.end();
            MyFont.Instance.end(updating_front);
            MySprite.Instance.end(updating_front);
            Sight.Instance.end(updating_front);
        }
Example #25
0
        void Awake()
        {
#if UNITY_PSP2
            UnityEngine.PSVita.Diagnostics.enableHUD = true;
#endif

            Application.targetFrameRate = 60;
            DontDestroyOnLoad(gameObject);

            stopwatch_ = new System.Diagnostics.Stopwatch();
            stopwatch_.Start();
            rendering_front_ = 0;

            Instance.init();
            Options.Instance.init();
            InputManager.Instance.init();
            GameManager.Instance.init();
            TaskManager.Instance.init();
            MyCollider.createPool();
            LockTarget.createPool();
            Missile.createPool();
            Bullet.createPool();
            Enemy.createPool();
            EnemyBullet.createPool();
            Debris.Instance.init(debris_material_);
            Spark.Instance.init(spark_material_);
            Beam.Instance.init(beam_material_);
            Trail.Instance.init(trail_material_);
            Explosion.Instance.init(explosion_material_);
            Hahen.Instance.init(hahen_material_);
            HUD.Instance.init();

            draw_buffer_ = new DrawBuffer[2];
            for (int i = 0; i < 2; ++i)
            {
                draw_buffer_[i].init();
            }
            manual_reset_event_ = new System.Threading.ManualResetEvent(false);
            setFPS(DefaultFps);
            update_frame_      = 0;
            update_sync_frame_ = 0;
            update_time_       = 0f;
            render_frame_      = 0;
            render_sync_frame_ = 0;
            pause_             = false;

            camera_          = GameObject.Find("MainCamera").GetComponent <Camera>(); // Camera.main;
            ProjectionMatrix = camera_.projectionMatrix;
            camera_.enabled  = false;
            if (player_prefab_ != null)
            {
                player_go_ = Instantiate(player_prefab_) as GameObject;
            }

            if (zako_prefab_ != null)
            {
                zako_pool_ = new GameObject[ZAKO_MAX];
                for (var i = 0; i < ZAKO_MAX; ++i)
                {
                    zako_pool_[i] = Instantiate(zako_prefab_) as GameObject;
                    zako_pool_[i].SetActive(false);
                }
            }

            uv_scroller_list_ = new UVScroller[8];

            // pause menu
            pausemenu_canvas_go_ = GameObject.Find("Canvas");
            if (pausemenu_canvas_go_ != null)
            {
                var go = GameObject.Find("FPSValue");
                fps_text_      = go.GetComponent <UnityEngine.UI.Text>();
                fps_text_.text = "1/" + fps_.ToString();
                pausemenu_canvas_go_.SetActive(false);
            }

            // audio
            audio_sources_bullet_ = new AudioSource[AUDIOSOURCE_BULLET_MAX];
            for (var i = 0; i < AUDIOSOURCE_BULLET_MAX; ++i)
            {
                audio_sources_bullet_[i]        = gameObject.AddComponent <AudioSource>();
                audio_sources_bullet_[i].clip   = se_bullet_;
                audio_sources_bullet_[i].volume = 0.05f;
            }
            audio_source_bullet_index_ = 0;
            audio_sources_explosion_   = new AudioSource[AUDIOSOURCE_EXPLOSION_MAX];
            for (var i = 0; i < AUDIOSOURCE_EXPLOSION_MAX; ++i)
            {
                audio_sources_explosion_[i]        = gameObject.AddComponent <AudioSource>();
                audio_sources_explosion_[i].clip   = se_explosion_;
                audio_sources_explosion_[i].volume = 0.25f;
            }
            audio_source_explosion_index_ = 0;
            audio_sources_missile_        = new AudioSource[AUDIOSOURCE_MISSILE_MAX];
            for (var i = 0; i < AUDIOSOURCE_MISSILE_MAX; ++i)
            {
                audio_sources_missile_[i]        = gameObject.AddComponent <AudioSource>();
                audio_sources_missile_[i].clip   = se_missile_;
                audio_sources_missile_[i].volume = 0.25f;
            }
            audio_source_missile_index_ = 0;
            audio_sources_lockon_       = new AudioSource[AUDIOSOURCE_LOCKON_MAX];
            for (var i = 0; i < AUDIOSOURCE_LOCKON_MAX; ++i)
            {
                audio_sources_lockon_[i]        = gameObject.AddComponent <AudioSource>();
                audio_sources_lockon_[i].clip   = se_lockon_;
                audio_sources_lockon_[i].volume = 0.25f;
            }
            audio_source_lockon_index_ = 0;

            audio_sources_voice_ikuyo_           = gameObject.AddComponent <AudioSource>();
            audio_sources_voice_ikuyo_.clip      = se_voice_ikuyo_;
            audio_sources_voice_ikuyo_.volume    = 0.75f;
            audio_sources_voice_uwaa_            = gameObject.AddComponent <AudioSource>();
            audio_sources_voice_uwaa_.clip       = se_voice_uwaa_;
            audio_sources_voice_uwaa_.volume     = 0.75f;
            audio_sources_voice_sorosoro_        = gameObject.AddComponent <AudioSource>();
            audio_sources_voice_sorosoro_.clip   = se_voice_sorosoro_;
            audio_sources_voice_sorosoro_.volume = 0.75f;
            audio_sources_voice_ototo_           = gameObject.AddComponent <AudioSource>();
            audio_sources_voice_ototo_.clip      = se_voice_ototo_;
            audio_sources_voice_ototo_.volume    = 0.75f;
            audio_sources_voice_yoshi_           = gameObject.AddComponent <AudioSource>();
            audio_sources_voice_yoshi_.clip      = se_voice_yoshi_;
            audio_sources_voice_yoshi_.volume    = 0.75f;

            audio_sources_bgm_        = gameObject.AddComponent <AudioSource>();
            audio_sources_bgm_.clip   = bgm01_;
            audio_sources_bgm_.volume = 0.5f;
            audio_sources_bgm_.loop   = true;

            gc_start_count_ = System.GC.CollectionCount(0 /* generation */);
        }
Example #26
0
        private void initialize()
        {
#if UNITY_PSP2
            UnityEngine.PSVita.Diagnostics.enableHUD = true;
#endif

            DontDestroyOnLoad(gameObject);

            stopwatch_ = new System.Diagnostics.Stopwatch();
            stopwatch_.Start();
            rendering_front_ = 0;

            camera_           = GameObject.Find("MainCamera").GetComponent <Camera>(); // Camera.main;
            camera_.eventMask = 0;

            {
                player_go_            = Instantiate(player_prefab_) as GameObject;
                player_arm_transform_ = player_go_.transform.Find("fighter_arm");
                {
                    var go = new GameObject();
                    go.name = "LockonRangeRenderer";
                    go.transform.position = CV.Vector3Zero;
                    go.transform.rotation = CV.QuaternionIdentity;
                    var lr = go.AddComponent <LockonRangeRenderer>();
                    LockonRangeRenderer.setInstance(lr);
                    go.transform.SetParent(player_go_.transform);
                    go.transform.localPosition = new Vector3(0f, 0.5f, 0f);
                }
                {
                    var go = new GameObject();
                    go.name = "ShieldRenderer";
                    go.transform.position = Vector3.zero;
                    go.transform.rotation = Quaternion.identity;
                    go.AddComponent <ShieldRenderer>();
                    go.transform.SetParent(player_go_.transform);
                    go.transform.localPosition = new Vector3(0f, 0f, 0f);
                }
            }

            Options.Instance.init();
            InputManager.Instance.init();
            GameManager.Instance.init();
            TaskManager.Instance.init();
            MyCollider.createPool();
            LockTarget.createPool();
            Missile.createPool();
            Bullet.createPool();
            Enemy.createPool();
            EnemyBullet.createPool();
            Shutter.createPool();
            Debris.Instance.init(debris_material_);
            Spark.Instance.init(spark_material_);
            Beam.Instance.init(beam_material_);
            Beam2.Instance.init(beam2_material_);
            Trail.Instance.init(trail_material_);
            Explosion.Instance.init(explosion_material_);
            Hahen.Instance.init(hahen_material_);
            Shockwave.Instance.init(shockwave_material_);
            // HUD.Instance.init();
            LockonRange.Instance.init(lockon_range_material_);
            LockonRangeRenderer.Instance.init(camera_);
            Shield.Instance.init(shield_material_);
            Sight.Instance.init(sight_material_);
            if (SightRenderer.Instance)
            {
                SightRenderer.Instance.init(camera_);
            }
            VRSprite.Instance.init(sprites_, vrsprite_material_);
            if (VRSpriteRenderer.Instance)
            {
                VRSpriteRenderer.Instance.init(camera_);
            }
            Notice.createPool();
            MySprite.Instance.init(sprites_, sprite_material_);
            MySpriteRenderer.Instance.init(camera_);
            MyFont.Instance.init(font_, font_material_);
            MyFontRenderer.Instance.init(camera_);

            draw_buffer_ = new DrawBuffer[2];
            for (int i = 0; i < 2; ++i)
            {
                draw_buffer_[i].init();
            }
            manual_reset_event_ = new System.Threading.ManualResetEvent(false);
#if UNITY_PS4
            setFPS(120);
#else
            setFPS(90);
#endif
            update_frame_      = 0;
            update_sync_frame_ = 0;
            update_time_       = 0f;
            render_frame_      = 0;
            render_sync_frame_ = 0;

            camera_holder_transform_ = camera_holder_.transform;
            ProjectionMatrix         = camera_.projectionMatrix;

            if (zako_prefab_ != null)
            {
                zako_pool_ = new GameObject[ZAKO_MAX];
                for (var i = 0; i < ZAKO_MAX; ++i)
                {
                    zako_pool_[i] = Instantiate(zako_prefab_) as GameObject;
                    zako_pool_[i].SetActive(false);
                }
            }
            if (dragon_head_prefab_ != null)
            {
                dragon_head_pool_ = new GameObject[DRAGON_HEAD_MAX];
                for (var i = 0; i < DRAGON_HEAD_MAX; ++i)
                {
                    dragon_head_pool_[i] = Instantiate(dragon_head_prefab_) as GameObject;
                    dragon_head_pool_[i].SetActive(false);
                }
            }
            if (dragon_body_prefab_ != null)
            {
                dragon_body_pool_ = new GameObject[DRAGON_BODY_MAX];
                for (var i = 0; i < DRAGON_BODY_MAX; ++i)
                {
                    dragon_body_pool_[i] = Instantiate(dragon_body_prefab_) as GameObject;
                    dragon_body_pool_[i].SetActive(false);
                }
            }
            if (dragon_tail_prefab_ != null)
            {
                dragon_tail_pool_ = new GameObject[DRAGON_TAIL_MAX];
                for (var i = 0; i < DRAGON_TAIL_MAX; ++i)
                {
                    dragon_tail_pool_[i] = Instantiate(dragon_tail_prefab_) as GameObject;
                    dragon_tail_pool_[i].SetActive(false);
                }
            }
            if (shutter_prefab_ != null)
            {
                shutter_pool_ = new GameObject[SHUTTER_MAX];
                for (var i = 0; i < SHUTTER_MAX; ++i)
                {
                    shutter_pool_[i] = Instantiate(shutter_prefab_) as GameObject;
                    shutter_pool_[i].SetActive(false);
                }
            }

            uv_scroller_list_ = new UVScroller[8];

            // audio
            audio_sources_bullet_ = new AudioSource[AUDIOSOURCE_BULLET_MAX];
            for (var i = 0; i < AUDIOSOURCE_BULLET_MAX; ++i)
            {
                audio_sources_bullet_[i]        = gameObject.AddComponent <AudioSource>();
                audio_sources_bullet_[i].clip   = se_bullet_;
                audio_sources_bullet_[i].volume = 0.4f;
            }
            audio_source_bullet_index_ = 0;
            audio_sources_explosion_   = new AudioSource[AUDIOSOURCE_EXPLOSION_MAX];
            for (var i = 0; i < AUDIOSOURCE_EXPLOSION_MAX; ++i)
            {
                audio_sources_explosion_[i]        = gameObject.AddComponent <AudioSource>();
                audio_sources_explosion_[i].clip   = se_explosion_;
                audio_sources_explosion_[i].volume = 0.25f;
            }
            audio_source_explosion_index_ = 0;
            audio_sources_missile_        = new AudioSource[AUDIOSOURCE_MISSILE_MAX];
            for (var i = 0; i < AUDIOSOURCE_MISSILE_MAX; ++i)
            {
                audio_sources_missile_[i]        = gameObject.AddComponent <AudioSource>();
                audio_sources_missile_[i].clip   = se_missile_;
                audio_sources_missile_[i].volume = 0.25f;
            }
            audio_source_missile_index_ = 0;
            audio_sources_lockon_       = new AudioSource[AUDIOSOURCE_LOCKON_MAX];
            for (var i = 0; i < AUDIOSOURCE_LOCKON_MAX; ++i)
            {
                audio_sources_lockon_[i]        = gameObject.AddComponent <AudioSource>();
                audio_sources_lockon_[i].clip   = se_lockon_;
                audio_sources_lockon_[i].volume = 0.20f;
            }
            audio_source_lockon_index_ = 0;
            audio_sources_shield_      = new AudioSource[AUDIOSOURCE_SHIELD_MAX];
            for (var i = 0; i < AUDIOSOURCE_SHIELD_MAX; ++i)
            {
                audio_sources_shield_[i]        = gameObject.AddComponent <AudioSource>();
                audio_sources_shield_[i].clip   = se_shield_;
                audio_sources_shield_[i].volume = 0.25f;
            }
            audio_source_shield_index_ = 0;

            audio_sources_voice_ikuyo_           = gameObject.AddComponent <AudioSource>();
            audio_sources_voice_ikuyo_.clip      = se_voice_ikuyo_;
            audio_sources_voice_ikuyo_.volume    = 0.75f;
            audio_sources_voice_uwaa_            = gameObject.AddComponent <AudioSource>();
            audio_sources_voice_uwaa_.clip       = se_voice_uwaa_;
            audio_sources_voice_uwaa_.volume     = 0.75f;
            audio_sources_voice_sorosoro_        = gameObject.AddComponent <AudioSource>();
            audio_sources_voice_sorosoro_.clip   = se_voice_sorosoro_;
            audio_sources_voice_sorosoro_.volume = 0.75f;
            audio_sources_voice_ototo_           = gameObject.AddComponent <AudioSource>();
            audio_sources_voice_ototo_.clip      = se_voice_ototo_;
            audio_sources_voice_ototo_.volume    = 0.75f;
            audio_sources_voice_yoshi_           = gameObject.AddComponent <AudioSource>();
            audio_sources_voice_yoshi_.clip      = se_voice_yoshi_;
            audio_sources_voice_yoshi_.volume    = 0.75f;

            audio_sources_bgm_        = gameObject.AddComponent <AudioSource>();
            audio_sources_bgm_.clip   = bgm01_;
            audio_sources_bgm_.volume = 0.5f;
            audio_sources_bgm_.loop   = true;
            is_bgm_playing_           = false;

            gc_start_count_ = System.GC.CollectionCount(0 /* generation */);

            my_camera_ = MyCamera.create();
            player_    = Player.create();

            flow_speed_target_ = 0f;
            flow_speed_        = 0f;
        }
Example #27
0
        private void main_loop()
        {
            long begin_time = stopwatch_.ElapsedTicks;

            // flip
            int updating_front = 1 - rendering_front_;

            // update
            if (!pause_)
            {
                // adaptive frame rate
                setFPS((int)(1f / elapsed_frame_time_));       // call here for stable DT during pause.

                if (Options.Instance.PerformanceMeter &&
                    InputManager.Instance.getButton(InputManager.Button.FFWPlus) > 0)
                {
                    fast_forward_ratio_ += 9;
                }
                if (InputManager.Instance.getButton(InputManager.Button.FFWMinus) > 0)
                {
                    fast_forward_ratio_ -= 9;
                }
                fast_forward_ratio_ = Mathf.Clamp(fast_forward_ratio_, 1, 10);

                for (var i = 0; i < fast_forward_ratio_; ++i)
                {
                    update_flow_speed(dt_);
                    TubeScroller.Instance.update(dt_, flow_speed_);
                    GameManager.Instance.update(dt_, update_time_);
                    Player.Instance.update(dt_, update_time_, flow_speed_);
                    TaskManager.Instance.update(dt_, update_time_, flow_speed_);
                    // lockon
                    bool locked = false;
                    if (player_.isNowLocking())
                    {
                        locked = LockTarget.checkAll(player_, update_time_);
                    }
                    // collision
                    MyCollider.calculate();

                    if (locked)
                    {
                        registSound(DrawBuffer.SE.Lockon);
                    }
                    if (InputManager.Instance.getButton(InputManager.Button.Pause) > 0)
                    {
                        pause_ = true;
                        registBgm(DrawBuffer.BGM.Pause);
                        registMotion(DrawBuffer.Motion.Pause);
                    }
                    ++update_frame_;
                    update_time_ += dt_;
                }
            }
            else
            {
                if (InputManager.Instance.getButton(InputManager.Button.Pause) > 0)
                {
                    pause_ = false;
                    registBgm(DrawBuffer.BGM.Resume);
                    registMotion(DrawBuffer.Motion.Resume);
                }
                else
                {
                    if (InputManager.Instance.getButton(InputManager.Button.Back) > 0)
                    {
                        long  elapsed_tick = stopwatch_.ElapsedTicks - pause_back_time_;
                        float elapsed      = (float)elapsed_tick / ((float)System.Diagnostics.Stopwatch.Frequency);
                        if (elapsed > 1f)
                        {
                            GameManager.Instance.setReplayMode(false);
                            restart();
                            pause_ = false;
                        }
                    }
                    else
                    {
                        pause_back_time_ = stopwatch_.ElapsedTicks;
                    }
                }
            }
            // profile
            update_tick_ = stopwatch_.ElapsedTicks - begin_time;
            begin_time   = stopwatch_.ElapsedTicks;

            // begin
            MyFont.Instance.begin();
            MySprite.Instance.begin();
            VRSprite.Instance.begin();
            Sight.Instance.begin();
            Beam.Instance.begin(updating_front);
            Beam2.Instance.begin(updating_front);
            Trail.Instance.begin(updating_front);
            Spark.Instance.begin();
            Explosion.Instance.begin();
            Hahen.Instance.begin();
            Shockwave.Instance.begin();
            Shield.Instance.begin();

            // renderUpdate
            draw_buffer_[updating_front].beginRender();
            my_camera_.renderUpdate(updating_front, ref draw_buffer_[updating_front]);
            player_.renderUpdate(updating_front, ref draw_buffer_[updating_front]);
            TaskManager.Instance.renderUpdate(updating_front, my_camera_, ref draw_buffer_[updating_front]);

            // debug info
            renderUpdate_debug_info(updating_front);

            // end
            Shield.Instance.end(updating_front);
            Shockwave.Instance.end(updating_front);
            Hahen.Instance.end(updating_front);
            Explosion.Instance.end(updating_front);
            Spark.Instance.end(updating_front);
            Trail.Instance.end();
            Beam2.Instance.end();
            Beam.Instance.end();
            Sight.Instance.end(updating_front);
            VRSprite.Instance.end(updating_front);
            MySprite.Instance.end(updating_front);
            MyFont.Instance.end(updating_front);

            render_update_tick_ = stopwatch_.ElapsedTicks - begin_time;
        }