Get it on Google Play


Wm뮤 :: 'Unity' 카테고리의 글 목록 (4 Page)

블로그 이미지
가끔 그림그리거나 3D모델링하거나
취미로 로봇만드는
전자과 게임프로그래머 (퇴사함)
2022.3.22f1 주로 사용
모카쨩
@Ahzkwid

Recent Comment

Archive


'Unity'에 해당되는 글 184건

  1. 2023.08.23 유니티 플랫폼 훅
  2. 2023.08.19 유니티 웨이포인트식 자율주행
  3. 2023.08.13 ugui에 3d 넣기
  4. 2023.08.12 다이나믹본 설정
  5. 2023.08.12 포톤 기초
  6. 2023.08.11 유니티 Final IK
  7. 2023.07.16 유니티 NavMesh
  8. 2023.04.25 PerlinNoise HLSL
2023. 8. 23. 10:46 Unity

 

 

 

검색해보면 여러가지 나온다

바닥오브젝트에 Parent 시키라느니

바닥오브젝트에 포지션값을 계산해서 추적시키라느니

심지어 AI도 이런 개소리를 한다

 

결론부터 말하자면

다 개소리고 그냥 유니티 물리엔진이 기본으로 지원해준다

 

 

근데 잘 보면 스피어는 각도추적이 안 되고 덩그러니 있는걸 볼수 있다

캡슐도 같은 문제다

아마 충돌면이 점이라서 마찰력 0으로 가정하나본데

당연히도 캐릭터들도 캡슐콜라이더를 많이 쓰기 때문에 같은 현상이 생긴다

(대체 언놈이 캡슐콜라이더 쓰라고 선동하고 다닌거지)

 

아무튼 그래서 해결방법

 

발이 닿는 부분에 박스콜라이더를 깔아준다

박스콜라이더가 위아래로 길쭉한 이유는 납작하게 하니 땅에 박힐때도 있드라

아이스크림 콘모양이 되어야 한다

 

 

 

Y축만 풀어주자

 

 

 

플랫폼 설정 차례다

그리고 가끔 패스이동등을 위해 좌표이동을 쓰는것들이 있는데

하단과 같이 치환해주면 된다

 

 

1안

velocity 이동

외력이 가해지면 날아가버리는 단점이 있다

더보기
private void FixedUpdate()
{
    //if (Time.time>1)
    {
        (var pos, var rot) = ProgressToPayloadPosition(progress);

        //rot= Quaternion.Lerp(payload.transform.rotation, rot, 0.1f);
        if (Vector3.Distance(payload.transform.position, pos)>2f)//2이상 이동은 텔레포트로 간주
        {
            payload.transform.position = pos;
            payload.transform.rotation = rot;
        }
        else
        {
            rot= Quaternion.Lerp(payload.transform.rotation, rot, 0.05f); //러프 반영

            var velocity = pos - payload.transform.position;
            //velocity는 초당 이동이므로 프레임당 이동으로 바꾸어주어야 한다고 하는데 어째선지 fixedDeltaTime을 넣으면 급가속으로 위치가 튄다
            //그래서 drag를 넣을까 했는데 얼마만큼 영향준다고도 안 써있고해서 그냥 퍼센테이지로 깎기로 함
            velocity /= Time.fixedDeltaTime;
            velocity *= 0.2f;
            payload.GetComponent<Rigidbody>().velocity = velocity;

            var angularVelocity = (rot * Quaternion.Inverse(payload.transform.rotation)).eulerAngles;
            angularVelocity.x = Mathf.DeltaAngle(0, angularVelocity.x);
            angularVelocity.y = Mathf.DeltaAngle(0, angularVelocity.y);
            angularVelocity.z = Mathf.DeltaAngle(0, angularVelocity.z);
            //얜 그냥 난리 부르스 추길래 fixedDeltaTime 안 넣음, 알고보니 맥스가 7이고 어째 얜 프레임당 기준인듯?
            payload.GetComponent<Rigidbody>().angularVelocity = angularVelocity;
        }


    }
}

 

그리고 가급적 플랫폼 질량을 높여두고

angular drag때문에 원하는 위치에 미반영 되는걸 막기위해 가급적 0으로 두자

 

 

 

2안

애니메이션 피직스를 사용

첫번째는 물리적인 이동이지만

이건 애니메이션이라 예정 좌표 말고 다른곳으로 가지 않는다

 

 

 

3안

이녀석에 페이로드에 제일 적합했다

애니메이션으로 균일한 이동속도는 만들기 어려우니까

(var pos, var rot) = ProgressToPayloadPosition(progress);

if (Vector3.Distance(payload.transform.position, pos) > 2f)//2이상 이동은 텔레포트로 간주
{
    payload.transform.position = pos;
    payload.transform.rotation = rot;
}
else
{
    pos = Vector3.Lerp(payload.transform.position, pos, 0.05f); //덜컹거림 방지
    rot = Quaternion.Lerp(payload.transform.rotation, rot, 0.05f); //덜컹거림 방지
    payload.GetComponent<Rigidbody>().MovePosition(pos);
    payload.GetComponent<Rigidbody>().MoveRotation(rot);
}

 

 

적용된 모습

 

 

 

 

'Unity' 카테고리의 다른 글

유니티 킬로그  (0) 2023.08.28
유니티 웨이포인트식 자율주행  (0) 2023.08.19
ugui에 3d 넣기  (0) 2023.08.13
posted by 모카쨩
2023. 8. 19. 09:18 Unity

 

개 노가다인데 게임오브젝트를 이렇게 촘촘히 박고

잘 기억은 안 나는데

해당 오브젝트 인근으로 이동하면 저기 있는 Target을 다음 지점으로 텔레포트 시켰던거 같다

기본상태에서는 Target을 차량의 살짝 앞에 뒀던거 같음

오랜만에 열어봤는데 일부 컴포넌트 유실이라...

'Unity' 카테고리의 다른 글

유니티 플랫폼 훅  (0) 2023.08.23
ugui에 3d 넣기  (0) 2023.08.13
다이나믹본 설정  (0) 2023.08.12
posted by 모카쨩
2023. 8. 13. 23:05 Unity

 

 

 

 

 

 

RawImage의 사이즈는

Render Camera Size / Canvas Scale * 2

하면 된다

 

 

 

 

 

 

결과물

 

화면비율 바꿔도 잘 된다

 

 

근데 이거 진짜 치명적인 문제가 있는데

캔버스의 렌더카메라에 할당되면 최우선으로 처리되기 때문에

같은 씬 안에 있는 모든 캔버스들이 최상단으로 올라온다. 어흑 마이깟

같은씬안에 캔버스를 다 꺼버려야 써먹을수 있다

 

 

 

 

 

 

다른 방법

 

더보기

 

카메라 할당을 전제로 해서 쓰면 평범하게 잘 된다

복잡한 게임은 멀티 카메라가 기본이니 힘들겠지만
단순한 게임은 이걸로 가능

 

 

다른 방법 2

대신 이건 LateUpdate에 뭔가 다른 카메라 로직 있으면 딜레이가 생긴다

public Transform camaraTracking;
void CameraTracking()
{
    var cam = Camera.main;
    if (cam)
    {
        camaraTracking.position = cam.transform.position;
        camaraTracking.rotation = cam.transform.rotation;
    }
}
void LateUpdate()
{
    CameraTracking();
}

 

 

 

'Unity' 카테고리의 다른 글

유니티 웨이포인트식 자율주행  (0) 2023.08.19
다이나믹본 설정  (0) 2023.08.12
유니티 Final IK  (0) 2023.08.11
posted by 모카쨩
2023. 8. 12. 21:18 Unity

루트본 설정할때 흰색선으로 나타나는 본을 확인하면서 맞추자


damping 탄성값, 젤리같은거 설정할때 낮출수록 좋음, 높을수록 스프링처럼 튀는거를 방지
elasticity 탄력값, 변형으로부터 얼마나 빨리 돌아올지
stffness 단단함, 관성에 얼마나 영향을 받을지,0으로 하면 움직여도 제자리
inert 둔한, 얼마나 늦게 반응할지 인듯? 아니면 다이나믹을 얼마나 적용할지일듯

 

 

 

 

옷, 헤어 등

 

 

가슴

 

 

꼬리

'Unity' 카테고리의 다른 글

ugui에 3d 넣기  (0) 2023.08.13
유니티 Final IK  (0) 2023.08.11
유니티 NavMesh  (0) 2023.07.16
posted by 모카쨩
2023. 8. 12. 18:50 Unity/Photon

 

 

 

또 오랫동안 안 쓰니 자꾸 까먹는다

기초를 까먹어서 나중에 찾는데 안 보임 ㅋㅋ;;

 

 

 

Photon Transform View

포톤판 ObjectSync이다

상위에 Photon View 있어야 함

 

'Unity > Photon' 카테고리의 다른 글

자주 쓰는 유니티 포톤챗 코드  (0) 2021.12.14
포톤 오류,에러 모음  (0) 2021.12.08
포톤 친구랑 같이 플레이  (0) 2021.11.24
posted by 모카쨩
2023. 8. 11. 05:11 Unity



 

 

브챗하면서 썼던 파이널 IK

오랜만에 다시 쓰려고 하니 기억이 안난다

그래서 정리

 

 

 

 

 

 

이건 좀 구형인데 이렇게 하고 타겟을 움직이면 따라간다

 

 

 

 

 

말그대로 Arm IK

Target으로 이동한다

유감스럽게도 아래의 Aim IK랑 동시적용은 안 된다

 

 

 

 

 

Aim IK

총구를 해당 장소에 향하게 할때 쓴다

근데 Aim IK를 쓰면 ParentConstraint가 먹통이 되니 주의

스크립트를 별도로 만들어서 연결시키는거보단 그냥 아마추어 하위에 프리팹 넣어주는게 더 간편할듯

 

Aim Transform은 총구 방향

Ribs는 체스트

Target은 쳐다보는 방향이다

스파인도 있으면 스파인도 넣어주는게 좋다

 

 

 

 

 

 

 

weight 조정

여기 올라간건 구버전이라 코드엔 안 나와있는데

애니메이션이랑 동시에 껐다 켰다 하면

일시적으로 에임 포인트가 차렷기준으로 잡혀서 허리가 돌아가 버린다

반드시 애니메이션을 먼저 키고 그 뒤 IK를 키고

끌때도 IK를 먼거 끄고 애니메이션을 끄자

var aimIK = animator.GetComponent<RootMotion.FinalIK.AimIK>();

var weight = 0f;
var lerpSpeed = 8f*Time.deltaTime;
if (GetWeaponSystem().weaponIndex == 2)
{
}
else
{
    if (attack)
    {
        if (Vector3.Distance(chest.transform.position, crosshair.HitPoint) > 1)
        {
            weight = 1;
        }
    }
    else
    {
        var nowTime = Time.time;
        var delay = 1;
        if (nowTime < weaponSlots[weaponSlotIndex].lastFireTime + delay)
        {
            weight = 1;
        }
        lerpSpeed = 4f * Time.deltaTime;
    }
}
if (GetComponent<PhotonCharacter>().hp <= 0)
{
    weight = 0;
    lerpSpeed = 1;
}
aimIK.solver.IKPositionWeight = Mathf.Lerp(aimIK.solver.IKPositionWeight, weight, lerpSpeed);

 

 

 

'Unity' 카테고리의 다른 글

다이나믹본 설정  (0) 2023.08.12
유니티 NavMesh  (0) 2023.07.16
유니티 애니메이션 관련  (0) 2023.04.03
posted by 모카쨩
2023. 7. 16. 20:00 Unity

 

 

 

길이 가져오기

도달했나 검사할때 씀

remainingDistance가 잘 안작동 해서 만듦

public static float GetPathLength(NavMeshPath path)
{
    float length = 0f;

    if ((path.status != NavMeshPathStatus.PathInvalid) && (path.corners!=null))
    {
        for (int i = 1; i < path.corners.Length; ++i)
        {
            length += Vector3.Distance(path.corners[i - 1], path.corners[i]);
        }
    }
    else
    {
        length = 99999f;
    }

    return length;
}

 

 

 

디버깅용

V1

if (Application.platform==RuntimePlatform.WindowsEditor)
{
    if ((path!=null)
        && (path.status != NavMeshPathStatus.PathInvalid) 
        && (path.corners != null))
    {
        for (int i = 0; i < path.corners.Length - 1; i++)
        {
            Debug.DrawLine(path.corners[i], path.corners[i + 1], Color.green);
        }
    }
}

 

V2

#if UNITY_EDITOR
void OnDrawGizmos()
{
    var agent = GetComponent<NavMeshAgent>();
    if (agent == null)
    {
        UnityEditor.Handles.Label(transform.position, "agent == null");
        return;
    }
    //var path = agent.path;
    if (path == null)
    {
        UnityEditor.Handles.Label(transform.position, "path == null");
        return;
    }
    if (path.status == NavMeshPathStatus.PathInvalid)
    {
        UnityEditor.Handles.Label(transform.position, "path.status == NavMeshPathStatus.PathInvalid");
        return;
    }
    if (path.corners == null)
    {
        UnityEditor.Handles.Label(transform.position, "path.corners == null");
        return;
    }
    if (path.corners.Length < 2)
    {
        UnityEditor.Handles.Label(transform.position, "path.corners.Length < 2");
        return;
    }
    UnityEditor.Handles.Label(transform.position, $"path.corners.Length : {path.corners.Length}\npath.corners[1] : {path.corners[1]}");
    for (int i = 0; i < path.corners.Length - 1; i++)
    {
        Debug.DrawLine(path.corners[i], path.corners[i + 1], Color.green);
    }
    Gizmos.DrawWireSphere(transform.position, agent.stoppingDistance);
}
#endif

 

 

 

 

목적지 설정


public void SetDestination(Transform target)
{
    var agent = GetComponent<NavMeshAgent>();
    if ((target != null) && (agent != null))
    {
        agent.SetDestination(target.position);
    }
    else
    {
        agent.ResetPath();
    }
}

 

 

 

패스를 WASD로 변경



/// <summary>
/// x는 horizon (-1 ~ 1)
/// y는 height (Mathf.NegativeInfinity ~ Mathf.Infinity)
/// z는 vertical (-1 ~ 1)
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
Vector3 Path2WASD(NavMeshPath path)
{
    if (path == null)
    {
        return Vector3.zero;
    }
    if (path.status == NavMeshPathStatus.PathInvalid)
    {
        return Vector3.zero;
    }
    if (path.corners == null)
    {
        return Vector3.zero;
    }
    var agent = GetComponent<NavMeshAgent>();

    var stoppingDistance = 0.1f;
    if (agent!=null)
    {
        stoppingDistance = agent.stoppingDistance;
    }

    if (stoppingDistance > GetPathLength(path))
    {
        return Vector3.zero;
    }



    if (path.corners.Length<2)
    {
        return Vector3.zero;
    }

    var movePos = path.corners[1];


    if (path.corners.Length >= 3)
    {
        if (Vector3.Distance(path.corners[0], path.corners[1]) < 0.1f)
        {
            movePos = path.corners[2];
        }
    }
    Debug.DrawLine(transform.position + Vector3.up * 0.1f, movePos + Vector3.up * 0.1f, Color.blue);

    var relativePosition = Quaternion.Inverse(transform.rotation) * (movePos - transform.position);
    var relativePosition2D = new Vector2(relativePosition.x, relativePosition.z).normalized;
    relativePosition = new Vector3(relativePosition2D.x, relativePosition.y, relativePosition2D.y);

    Debug.DrawLine(transform.position + Vector3.up * 0.2f, transform.position + transform.rotation*relativePosition + Vector3.up * 0.2f, Color.red);
    return relativePosition;
}

 

'Unity' 카테고리의 다른 글

유니티 Final IK  (0) 2023.08.11
유니티 애니메이션 관련  (0) 2023.04.03
구글플레이 앱 이전  (0) 2023.03.06
posted by 모카쨩
2023. 4. 25. 03:07 Unity/shader

 

Shader "Perlin/Noise"
{
    Properties
    {
        [HideInInspector]_MainTex ("Texture", 2D) = "white" {}
		[PowerSlider(4)]_Scale("Scale", Range(0,8192)) = 1000
		_Speed("Speed", Range(0,8)) = 0
		//[HideInInspector]
        _Key("Key", float) = 0
    }
    SubShader
    {
		Tags{
			"RenderType" = "Transparent"
			"Queue" = "Transparent"
            "IgnoreProjector"="True"
		}

        LOD 100
        
		blend srcalpha oneminussrcalpha
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // make fog work
            #pragma multi_compile_fog

            #include "UnityCG.cginc"
            float _Speed;
            float _Key;
            float interpolate(float a0, float a1, float w) {
                /* // You may want clamping by inserting:
                 * if (0.0 > w) return a0;
                 * if (1.0 < w) return a1;
                 */
                return (a1 - a0) * w + a0;
                /* // Use this cubic interpolation [[Smoothstep]] instead, for a smooth appearance:
                 * return (a1 - a0) * (3.0 - w * 2.0) * w * w + a0;
                 *
                 * // Use [[Smootherstep]] for an even smoother result with a second derivative equal to zero on boundaries:
                 * return (a1 - a0) * ((w * (w * 6.0 - 15.0) + 10.0) * w * w * w) + a0;
                 */
            }
            float2 randomGradient(int ix, int iy) {
                // No precomputed gradients mean this works for any number of grid coordinates
                uint w = 8 * (4294967295+1);
                uint s = w / 2; // rotation width
                uint a = ix, b = iy;
                a *= 3284157443; 
                b ^= a << s | a >> w-s;
                b *= 1911520717; 
                a ^= b << s | b >> w-s;
                a *= 2048419325;
                float random = a * (3.14159265 / ~(~0u >> 1)); // in [0, 2*Pi]
                random += _Time.y*_Speed;
                random += _Key;
                float2 v;
                v.x = cos(random); v.y = sin(random);
                return v;
            }
            // Computes the dot product of the distance and gradient vectors.
            float dotGridGradient(int ix, int iy, float x, float y) {
                // Get gradient from integer coordinates
                float2 gradient = randomGradient(ix, iy);

                // Compute the distance vector
                float dx = x - (float)ix;
                float dy = y - (float)iy;

                // Compute the dot-product
                return (dx*gradient.x + dy*gradient.y);
            }
            // Compute Perlin noise at coordinates x, y
            float perlin(float x, float y) {
                // Determine grid cell coordinates
                int x0 = (int)floor(x);
                int x1 = x0 + 1;
                int y0 = (int)floor(y);
                int y1 = y0 + 1;

                // Determine interpolation weights
                // Could also use higher order polynomial/s-curve here
                float sx = x - (float)x0;
                float sy = y - (float)y0;

                // Interpolate between grid point gradients
                float n0, n1, ix0, ix1, value;

                n0 = dotGridGradient(x0, y0, x, y);
                n1 = dotGridGradient(x1, y0, x, y);
                ix0 = interpolate(n0, n1, sx);

                n0 = dotGridGradient(x0, y1, x, y);
                n1 = dotGridGradient(x1, y1, x, y);
                ix1 = interpolate(n0, n1, sx);

                value = interpolate(ix0, ix1, sy);
                return value; // Will return in range -1 to 1. To make it in range 0 to 1, multiply by 0.5 and add 0.5
            }
            float perlin(float2 uv) {
                return perlin(uv.x,uv.y)*0.5+0.5; 
            }
            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                UNITY_FOG_COORDS(1)
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float _Scale;
            
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                UNITY_TRANSFER_FOG(o,o.vertex);
                return o;
            }


            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = 1;
                col.rgb = perlin(i.uv*_Scale);
                return col;
            }
            ENDCG
        }
    }
}

 

내가 포팅한 펄린노이즈임

원문은 https://en.wikipedia.org/wiki/Perlin_noise 에서 가져왔고

포팅만 했을뿐 만든건 Ken Perlin이므로 어떻게 쓰던 알바아님😜

자기가 포팅했다고 하는 노양심짓만 안 해주면 좋을듯

'Unity > shader' 카테고리의 다른 글

DepthCameraTexture를 _CameraDepthTexture처럼 쓰기  (0) 2023.10.14
스크린 오버레이 샘플  (0) 2023.01.20
유니티 스카이박스 관련  (0) 2023.01.16
posted by 모카쨩

저사양 유저용 블로그 진입