반응형

Unity의 UI쪽 컴포넌트를 주로 많이 사용하고 있는데
예를 들면 ScrollRect라던가 Button, Text 등등 많이 많이 사용하는 중이다.
근데 너무 잘 만들어진 이 컴포넌트들도 사용하다 보면 약간의 변형을 해서 사용해야 할 경우가 있는데 문제는 상속받아와서 직접 커스터마이징 한 파일을 게임오브젝트에 적용을 하면 내가 추가한 변수들이나 요소들이 Inspector에 보여지지 않고 기존의 상속했던 클래스의 인스펙터 내용만 보여지게 된다.

해결책은 파일 하나만 만들어주면 된다.
Assets폴더 안에 Editor폴더를 하나 만들고 원하는 이름으로 파일을 하나 만든다. 이 때 파일 이름은 “커스터마이징 한 클래스의 이름+Editor.cs” 로 만드는게 헷갈리지 않을 것이다.

아래 예제로 작성한 파일의 LevelHandler라는 클래스는 ScrollRect를 상속받아와서 커스터마이징한 파일이다. Inspector의 내용이 기존 ScrollRect의 내용으로 바뀌지 않는데 아래와 같이 해주면 추가한 부분들이 기존 내용 아랫쪽으로 보여지게 된다.

파일 내용은 다음과 같이 작성하면 된다.

 
1
2
3
4
5
6
7
8
9
10
11
12
using UnityEngine;
using UnityEditor;
[CustomEditor(typeof(LevelHandler))]
public class LevelHandlerEditor : Editor
{
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
        if (GUI.changed)
            EditorUtility.SetDirty(target);
    }
}

중요한건 3번째 줄 부분이다.
[CustomEditor(typeof(커스터마이징 한 클래스))]

(추가하기 전 Inspector 모습)

%ec%8a%a4%ed%81%ac%eb%a6%b0%ec%83%b7-2016-10-24-%ec%98%a4%ed%9b%84-4-32-52

(추가 후 Inspector 모습)

%ec%8a%a4%ed%81%ac%eb%a6%b0%ec%83%b7-2016-10-24-%ec%98%a4%ed%9b%84-4-33-19

기존 내용의 아랫쪽으로 내가 추가 한 내용들이 보여지는 것을 확인 할 수 있다.

반응형
저작자표시

'unity C#' 카테고리의 다른 글

[Unity] 스프라이트 시퀀스 애니메이션 손쉽게 사용하기  (0) 2017.11.06
[Unity] 메모리 관리 불필요한 메모리 누수 막기  (0) 2017.11.06
[Unity] Singleton을 Generic 으로 만들기  (0) 2017.11.06
[Unity] 뷰포리아 안드로이드 카메라 Auto Focus 활성화하기  (0) 2017.11.06
[Unity] GUI Infinity Scroll List 무한 리스트 구현 Json  (0) 2016.01.19
반응형

프로젝트 진행하면 꼭 사용하는 Singleton 형태의 파일을 만드는 경우가 생기는데
이 Singleton을 간단하게 만들어주는 방법이다.

 

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using UnityEngine;
 
public class SingletonHandler<T> : MonoBehaviour where T : MonoBehaviour
{
    private static T instance;
 
    public static T Instance
    {
        get
        {
            if (!instance)
            {
                GameObject obj;
                obj = GameObject.Find(typeof(T).Name);
                if (!obj)
                {
                    obj = new GameObject(typeof(T).Name);
                    instance = obj.AddComponent<T>();
                }
                else
                {
                    instance = obj.GetComponent<T>();
                }
            }
            return instance;
        }
    }
 
    public void Awake()
    {
DontDestroyOnLoad(gameObject);
    }
}

Singleton을 만들때는 이렇게만 해주면 된다.

 
1
2
3
4
5
6
using UnityEngine;
 
public class TestHandler : SingletonHandler<TestHandler>
{
 
}

참조 : http://sillyknight.tistory.com/30

반응형
저작자표시

'unity C#' 카테고리의 다른 글

[Unity] 메모리 관리 불필요한 메모리 누수 막기  (0) 2017.11.06
[Unity] 상속받아온 클래스의 Inspector 수정하기.  (1) 2017.11.06
[Unity] 뷰포리아 안드로이드 카메라 Auto Focus 활성화하기  (0) 2017.11.06
[Unity] GUI Infinity Scroll List 무한 리스트 구현 Json  (0) 2016.01.19
[Unity] Application.LoadLevel 사용시 fadeIn fadeOut 효과  (0) 2016.01.14
반응형

 
 
 
 
 
 
C#
 
 

 

 
1
2
3
4
void AutoFocusOn()
{
     CameraDevice.Instance.SetFocusMode(CameraDevice.FocusMode.FOCUS_MODE_CONTINUOUSAUTO);
}

 

매니페스트 수정

<uses-permission android:name=”android.permission.CAMERA” />
: 카메라를 사용할 것이다

<uses-feature android:name=”android.hardware.camera” />
:카메라의 특수기능을 사용할 것이다

<uses-feature android:name=”android.hardware.camera.autofocus” />
:카메라 오토포커싱을 사용할 것이다

 

뷰포리아가 Init된 이후의 타이밍에 호출되어야 함.

 

출처 : http://qits.tistory.com/entry/뷰포리아-오토포커싱-활성화하기

반응형
저작자표시

'unity C#' 카테고리의 다른 글

[Unity] 상속받아온 클래스의 Inspector 수정하기.  (1) 2017.11.06
[Unity] Singleton을 Generic 으로 만들기  (0) 2017.11.06
[Unity] GUI Infinity Scroll List 무한 리스트 구현 Json  (0) 2016.01.19
[Unity] Application.LoadLevel 사용시 fadeIn fadeOut 효과  (0) 2016.01.14
[Unity] Vector3 position 여러 타겟일때 중점 찾기 Camera  (0) 2016.01.12
반응형

어떻게 보면 간단한 구현 일 수도 있겠지만
난 어려웠다. ㅠㅠ 그래서 다시 정리하는 차원에서 포스팅 해본다.

먼저 간략하게 요약해보자면…
Unity의 기본제공되는 GUI를 사용,
데이터 형태는 Json형태로 만들어서 사용하기 편리하도록 parsing을 거친 뒤 구현하였다. 동작 원리는 스크롤 시 화면에 보여지는 부분의 GameObject(Item)만 생성하여 Draw Call을 줄이는 방식으로, 업 스크롤 시 위로 올라가는 Item을 아래로 이동시켜 아랫쪽 데이터를 붙이고, 다운 스크롤 시 아래로 내려가는 Item을 위로 이동시켜  위쪽 데이터를 붙이는 방식이다. 아이템을 잡고 있는 GameObject의 길이는 최초에 계산되어 전체 Item 갯수만큼의 길이로 생성되어진다.
자전거의 톱니와 체인을 생각하면 쉽게 이해될듯하다.

Hierarchy 구성

스크린샷 2016-01-19 오후 12.27.42

스크립트 구성

스크린샷 2016-01-19 오후 4.25.59

테스트용 데이터 세팅하기
먼저 JsonData를 만들자
Assets > Resources 폴더를 만들고 그 안에 data.txt 파일을 하나 만든 후 아래와 같이 코딩한다. 참고로 data.txt는 그냥 아무 파일 하나 만들어서 확장명만 바꿔주면 된다.
데이터 형태는 나중에 어떻게든 바꿔서 사용할 수 있다.

data.text

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
{
  "music":[
    {
      "songtitle" : "Love Will Show You Everything",
      "singer" : "Various Artists",
      "image" : "image/Love Will Show You Everything",
      "genre" : "rock",
      "playtime" : "0"
    },
    {
      "songtitle" : "Love Will Show You Everything",
      "singer" : "Various Artists",
      "image" : "image/Love Will Show You Everything",
      "genre" : "rock",
      "playtime" : "0"
    },
 
    //...(최소 20개 이상은 되어야 테스트 해보기 좋으니 적당히 반복해서 복사하자.)
 
    {
      "songtitle" : "Love Will Show You Everything",
      "singer" : "Various Artists",
      "image" : "image/Love Will Show You Everything",
      "genre" : "rock",
      "playtime" : "0"
    }
  ]
}

Hierarchy의 Manager에 ManagerHandler, ModelHandler, ListModel 라는 이름으로 C# Script 3개를 생성하고 아래와 같이 코딩한다.

ManagerHandler.cs

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
using UnityEngine;
 
public class ManagerHandler : MonoBehaviour {
    public InfiniteScroll infiniteScroll;
void Start () {
        Application.targetFrameRate = 60;
        initList();
}
    
    void initList()
    {
        infiniteScroll.ListStart();
    }
}

 

ListModel.cs

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
using UnityEngine;
using System.Collections.Generic;
 
 
public struct DataVO{
    public string SongTitle;
    public string Singer;
    public string Image;
    public string Genre;
    public float PlayTime;
}
 
public class ListModel : MonoBehaviour {
    private static ListModel _instance = null;    
    public DataVO dataVO;    
    public List<DataVO> MusicList = new List<DataVO>();    
    public static ListModel Instance{
        get{
            if(_instance == null){
                _instance = (GameObject.Find("Manager")).AddComponent<ListModel>();
            }            
            return _instance;
        }
    }
 
}

 

ModelHandler.cs

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
using UnityEngine;
using System.Collections.Generic;
using LitJson;
 
public class ModelHandler : MonoBehaviour {    
    private JsonData jsonData;
    public List<DataVO> List;
    string jsonString(){
        TextAsset t = (TextAsset) Resources.Load("data", typeof(TextAsset));
        return t.text;
    }
 
void Awake () {        
        jsonData = JsonMapper.ToObject( jsonString() );        
        parsing();        
}
    
    void parsing(){
        for(int i=0; i<jsonData["music"].Count; i++){
            
            ListModel.Instance.dataVO.SongTitle = (string) jsonData["music"][i]["songtitle"];
            ListModel.Instance.dataVO.Singer = (string) jsonData["music"][i]["singer"];
            ListModel.Instance.dataVO.Image = (string) jsonData["music"][i]["image"];
            ListModel.Instance.dataVO.Genre = (string) jsonData["music"][i]["genre"];
            ListModel.Instance.dataVO.PlayTime = float.Parse( (string) jsonData["music"][i]["playtime"] );
            
            ListModel.Instance.MusicList.Add(ListModel.Instance.dataVO);
        }
    }    
}

LitJson.dll은 여기에서 받을 수 있으며 Assets > Plugins(생성) 폴더에 넣어준다.

구현하기
먼저 Hierarchy의 ScrollRect(GameObject)에 ScrollRect 콤포넌트를 붙인다.
Infinity Content(GameObject)에 InfiniteScroll라는 C# Script을 생성한 후 아래와 같이 코딩한다.

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
using UnityEngine.EventSystems;
 
public class InfiniteScroll : MonoBehaviour
{
[SerializeField]
private RectTransform m_ItemBase;
[SerializeField, Range(0, 30)]
int m_instantateItemCount = 9;    
    [SerializeField]
    float m_itemWidth = 1080;
    [SerializeField]
    float m_itemHeight = 200;
    [SerializeField]
    float gap = 10;    
public Direction direction;
[System.NonSerialized]
public List<RectTransform> m_itemList = new List<RectTransform> ();
protected float m_diffPreFramePosition = 0;
protected int m_currentItemNo = 0;
public ScrollRect scrollRect;
public List<DataVO> listData;
public enum Direction
{
Vertical,
Horizontal,
}
 
//For Event
private const float inchToCm = 2.54f;
[SerializeField]
private EventSystem eventSystem = null;
[SerializeField]
private float dragThresholdCM = 0.5f;
//For drag Threshold
private void SetDragThreshold()
{
if (eventSystem != null)
{
eventSystem.pixelDragThreshold = (int)(dragThresholdCM * Screen.dpi / inchToCm);
}
}
 
// cache component
private RectTransform m_rectTransform;
protected RectTransform _RectTransform {
get {
if (m_rectTransform == null)
m_rectTransform = GetComponent<RectTransform> ();
return m_rectTransform;
}
}
 
private float AnchoredPosition
{
get{
return (direction == Direction.Vertical ) ?
                -_RectTransform.anchoredPosition.y:
                _RectTransform.anchoredPosition.x;
}
}
    private float ItemScale{
        get{
            return (direction == Direction.Vertical) ?
            m_itemHeight :
            m_itemWidth;
        }
    }
 
void Awake()
{
SetDragThreshold();
}
 
public void ListStart ()
{
listData = ListModel.Instance.MusicList;
        
if(listData.Count<m_instantateItemCount){
m_instantateItemCount = listData.Count;
}else{
            m_instantateItemCount = (direction == Direction.Vertical) ?
                (int) System.Math.Truncate( Screen.height / ItemScale ) + 3 :
                (int) System.Math.Truncate( Screen.width / ItemScale ) + 3;
}
 
// create items
scrollRect.horizontal = direction == Direction.Horizontal;
scrollRect.vertical = direction == Direction.Vertical;
scrollRect.content = _RectTransform;
        
        if(direction == Direction.Vertical){
            scrollRect.content.GetComponent<RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, (ItemScale + gap) * (listData.Count-1) + gap );
            scrollRect.content.GetComponent<RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, m_itemWidth + gap*2);
        }else{
            scrollRect.content.GetComponent<RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, (ItemScale + gap) * (listData.Count-1) + gap );
            scrollRect.content.GetComponent<RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, m_itemHeight + gap*2 );
        }
        
        
scrollRect.onValueChanged.AddListener (valueChange);
        Debug.Log( listData.Count );
 
m_ItemBase.gameObject.SetActive (false);
 
for (int i=0; i<m_instantateItemCount; i++) {
var item = GameObject.Instantiate (m_ItemBase) as RectTransform;
item.SetParent (transform, false);
item.name = i.ToString ();
            
            if(direction == Direction.Vertical){
                item.GetComponent<RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, m_itemWidth - gap*2);
                item.GetComponent<RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, m_itemHeight);
            }else{                
                item.GetComponent<RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, m_itemWidth);
                item.GetComponent<RectTransform>().SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, m_itemHeight);
            }
            
item.anchoredPosition =
(direction == Direction.Vertical ) ?
new Vector2 (gap, - gap - (ItemScale + gap) * i) :
new Vector2 ((ItemScale + gap) * i + gap, -gap) ;
m_itemList.Add (item);
 
item.gameObject.SetActive (true);
            item.GetComponent<Item>().UpdateItem(i);
}
}
 
private void valueChange(Vector2 _pos)
{        
        // scroll up, item attach bottom  or  right
        while(AnchoredPosition - m_diffPreFramePosition < -(ItemScale + gap)*2 ){
            m_diffPreFramePosition -= (ItemScale + gap);
            
            var item = m_itemList [0];
            m_itemList.RemoveAt (0);
            m_itemList.Add (item);
            
            var pos = (ItemScale + gap) * m_instantateItemCount + (ItemScale + gap) * m_currentItemNo ;
item.anchoredPosition = (direction == Direction.Vertical ) ? new Vector2 (gap, -pos - gap) : new Vector2 (pos + gap , -gap);
 
m_currentItemNo ++;
            
            if(m_currentItemNo + m_instantateItemCount < listData.Count){
                item.GetComponent<Item>().UpdateItem(m_currentItemNo + m_instantateItemCount);
            }else{
                item.GetComponent<Item>().UpdateItem(-100);
            }
        }
        
        // scroll down, item attach top  or  left
        while(AnchoredPosition - m_diffPreFramePosition > 0){
            m_diffPreFramePosition += (ItemScale + gap);
            
            var itemListLastCount = m_instantateItemCount - 1;
var item = m_itemList [itemListLastCount];
m_itemList.RemoveAt (itemListLastCount);
m_itemList.Insert (0, item);
            
            m_currentItemNo --;
            
            var pos = (ItemScale + gap) * m_currentItemNo + gap;
item.anchoredPosition = (direction == Direction.Vertical ) ? new Vector2 (gap, -pos ): new Vector2 (pos, -gap);
            
            if(m_currentItemNo > -1){
                item.GetComponent<Item>().UpdateItem(m_currentItemNo);
            }else{
                item.GetComponent<Item>().UpdateItem(-100);
            }
        }
}
}

 

Item(GameObject)에 Item 이라는 이름으로 C# Script를 생성해서 다름과 같이 코딩한다. 아이템 부분은 적당히 수정해서 사용할 수 있을 것이다.

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using UnityEngine;
using UnityEngine.UI;
 
public class Item : MonoBehaviour
{    
public Text m_Text;
public Image m_Image;
 
public void UpdateItem (int count)
{
        if(count == -100){
            gameObject.GetComponent<Image>().enabled = false;
            m_Text.gameObject.SetActive(false);
            m_Image.gameObject.SetActive(false);
        }else{
            gameObject.GetComponent<Image>().enabled = true;
            m_Text.gameObject.SetActive(true);
            m_Image.gameObject.SetActive(true);
            m_Text.text = count+1 + " - " + Screen.width + " x " + Screen.height;
            m_Image.sprite = Resources.Load<Sprite>(ListModel.Instance.MusicList[count].Image);
        }
}
}

 

Infinity Content의 Inspector가 보이도록 한 후 아래 그림에서 보이는 것 처럼 드래그해서 각 해당 되는곳으로 넣어 준 후 ItemWidth, ItemHeight, Gap 에 원하는 사이즈를 입력한다.

스크린샷 2016-01-19 오후 5.05.25

 

마찬가지로 Item또한 아래 그림처럼 드래드앤 드롭해준다.

스크린샷 2016-01-19 오후 5.13.05

 

Manager도 아래와 같이 Infinity Content를 드래그 앤 드롭 해준다.

스크린샷 2016-01-19 오후 5.16.12

반응형
저작자표시

'unity C#' 카테고리의 다른 글

[Unity] Singleton을 Generic 으로 만들기  (0) 2017.11.06
[Unity] 뷰포리아 안드로이드 카메라 Auto Focus 활성화하기  (0) 2017.11.06
[Unity] Application.LoadLevel 사용시 fadeIn fadeOut 효과  (0) 2016.01.14
[Unity] Vector3 position 여러 타겟일때 중점 찾기 Camera  (0) 2016.01.12
[Unity] android screenshot 갤러리 갱신 업데이트 방법  (0) 2016.01.12
반응형

unity에서 지원되는 Application.LoadLevel을 사용하면 Scene과 Scene간의 이동이 가능하지만 이동할 때 아무런 효과없이 이동이 된다. 프로젝트마다 성향이 달라서 모두 적용되기는 힘들 수도 있겠지만 찾아보다 가장 무난하다 싶은걸 찾아서 작동이 잘 되도록 수정하였다. unity의 GL class를 사용하여 Scene이동시 Quad를 그려 자연스럽게 이동되게 한다.
AutoFade.cs 파일을 적당한 폴더에 넣어서 사용하면 편리할 듯 하다.

참고 : http://www.devkorea.co.kr/reference/Documentation/ScriptReference/GL.QUADS.html,
How to Fade Between Scenes in Unity,
Unity3D load level with fade effect

호출 할 때

1
2
3
AutoFade.LoadLevel("User Scene Name",0.5f,0.5f,Color.black);
//or
AutoFade.LoadLevel("User Scene Index Number",0.5f,0.5f,Color.black);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
using UnityEngine;
using System.Collections;
public class AutoFade : MonoBehaviour
{
    private static AutoFade m_Instance = null;
    public Material mat;
    private Mesh mesh;
    private string m_LevelName = "";
    private int m_LevelIndex = 0;
    private bool m_Fading = false;
    private static AutoFade Instance
    {
        get
        {
            if (m_Instance == null)
            {
                m_Instance = (new GameObject("AutoFade")).AddComponent<AutoFade>();
            }
            return m_Instance;
        }
    }
    public static bool Fading
    {
        get { return Instance.m_Fading; }
    }
    private void Awake()
    {
        DontDestroyOnLoad(this);
        m_Instance = this;
        mat = new Material(Shader.Find("UI/Default"));    
        mesh = new Mesh();
    }
    private void DrawQuad(Color aColor,float aAlpha)
    {
        if (!mat) {
            Debug.LogError("Please Assign a material on the inspector");
            return;
        }
        GL.PushMatrix();
        mat.SetPass(0);
        GL.LoadOrtho();
        GL.Begin(GL.QUADS);
        GL.Color(new Vector4(aColor.r, aColor.g, aColor.b, aAlpha));
        GL.Vertex3(0, 0, -1);
        GL.Vertex3(0, 1, -1);
        GL.Vertex3(1, 1, -1);
        GL.Vertex3(1, 0, -1);
        GL.End();
        GL.PopMatrix();
     }
    private IEnumerator Fade(float aFadeOutTime, float aFadeInTime, Color aColor)
    {
        float t = 0.0f;
        while (t<1.0f)
        {
            yield return new WaitForEndOfFrame();
            t = Mathf.Clamp01(t + Time.deltaTime / aFadeOutTime);
            DrawQuad(aColor,t);
            Debug.Log("fade : " + t);
        }
        if (m_LevelName != "")
            Application.LoadLevel(m_LevelName);
        else
            Application.LoadLevel(m_LevelIndex);
        while (t>0.0f)
        {
            yield return new WaitForEndOfFrame();
            t = Mathf.Clamp01(t - Time.deltaTime / aFadeInTime);
            DrawQuad(aColor,t);
            Debug.Log("fade : "+t );
        }
        //  OnPostRender();
        m_Fading = false;
    }
    private void StartFade(float aFadeOutTime, float aFadeInTime, Color aColor)
    {
        m_Fading = true;
        StartCoroutine(Fade(aFadeOutTime, aFadeInTime, aColor));
    }
    public static void LoadLevel(string aLevelName,float aFadeOutTime, float aFadeInTime, Color aColor)
    {
        if (Fading) return;
        Instance.m_LevelName = aLevelName;
        Instance.StartFade(aFadeOutTime, aFadeInTime, aColor);
    }
    public static void LoadLevel(int aLevelIndex,float aFadeOutTime, float aFadeInTime, Color aColor)
    {
        if (Fading) return;
        Instance.m_LevelName = "";
        Instance.m_LevelIndex = aLevelIndex;
        Instance.StartFade(aFadeOutTime, aFadeInTime, aColor);
    }
}


상단 메뉴에서 File/Build Setting 에 다음과같이 사용하고자 하는 Scene을 넣어줘야한다.


반응형
저작자표시

'unity C#' 카테고리의 다른 글

[Unity] 뷰포리아 안드로이드 카메라 Auto Focus 활성화하기  (0) 2017.11.06
[Unity] GUI Infinity Scroll List 무한 리스트 구현 Json  (0) 2016.01.19
[Unity] Vector3 position 여러 타겟일때 중점 찾기 Camera  (0) 2016.01.12
[Unity] android screenshot 갤러리 갱신 업데이트 방법  (0) 2016.01.12
[Unity] Bitmap Drawing API 사용해보기  (1) 2015.11.11
반응형

Unity 게임 Tutorial을 따라하다 아주 간단하게 두 타겟 또는 그 이상의 타겟의 중점을 구하고 카메라 줌인/아웃 시키는 공식이 있길래 포스팅 한다. 너무도 간단?하다…

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
using UnityEngine;
 
public class CameraControl : MonoBehaviour
{
    public float m_DampTime = 0.2f;                
    public float m_ScreenEdgeBuffer = 4f;          
    public float m_MinSize = 6.5f;                  
    [HideInInspector] public Transform[] m_Targets;
 
 
    private Camera m_Camera;                        
    private float m_ZoomSpeed;                      
    private Vector3 m_MoveVelocity;                
    private Vector3 m_DesiredPosition;              
 
 
    private void Awake()
    {
        m_Camera = GetComponentInChildren<Camera>();
    }
 
 
    private void FixedUpdate()
    {
        Move();
        Zoom();
    }
 
 
    private void Move()
    {
        FindAveragePosition();
 
        transform.position = Vector3.SmoothDamp(transform.position, m_DesiredPosition, ref m_MoveVelocity, m_DampTime);
    }
 
 
    private void FindAveragePosition()
    {
        Vector3 averagePos = new Vector3();
        int numTargets = 0;
 
        for (int i = 0; i < m_Targets.Length; i++)
        {
            if (!m_Targets[i].gameObject.activeSelf)
                continue;
 
            averagePos += m_Targets[i].position;
            numTargets++;
        }
        
 
        if (numTargets > 0)
            averagePos /= numTargets;
 
        averagePos.y = transform.position.y;
 
        m_DesiredPosition = averagePos;
    }
 
 
    private void Zoom()
    {
        float requiredSize = FindRequiredSize();
        m_Camera.orthographicSize = Mathf.SmoothDamp(m_Camera.orthographicSize, requiredSize, ref m_ZoomSpeed, m_DampTime);
    }
 
 
    private float FindRequiredSize()
    {
        Vector3 desiredLocalPos = transform.InverseTransformPoint(m_DesiredPosition);
        
        float size = 0f;
 
        for (int i = 0; i < m_Targets.Length; i++)
        {
            if (!m_Targets[i].gameObject.activeSelf)
                continue;
 
            Vector3 targetLocalPos = transform.InverseTransformPoint(m_Targets[i].position);
            
            Vector3 desiredPosToTarget = targetLocalPos - desiredLocalPos;
 
            size = Mathf.Max (size, Mathf.Abs (desiredPosToTarget.y));
 
            size = Mathf.Max (size, Mathf.Abs (desiredPosToTarget.x) / m_Camera.aspect);
        }
        
        size += m_ScreenEdgeBuffer;
 
        size = Mathf.Max(size, m_MinSize);
        
        return size;
    }
 
 
    public void SetStartPositionAndSize()
    {
        FindAveragePosition();
 
        transform.position = m_DesiredPosition;
 
        m_Camera.orthographicSize = FindRequiredSize();
    }
}

사실 Vector3 + Vector3하면 각 x,y,z가 각각 합해 진다는 생각조차 하지 못했다.
메인 카메라의 이동에 사용되었다.

반응형
저작자표시

'unity C#' 카테고리의 다른 글

[Unity] GUI Infinity Scroll List 무한 리스트 구현 Json  (0) 2016.01.19
[Unity] Application.LoadLevel 사용시 fadeIn fadeOut 효과  (0) 2016.01.14
[Unity] android screenshot 갤러리 갱신 업데이트 방법  (0) 2016.01.12
[Unity] Bitmap Drawing API 사용해보기  (1) 2015.11.11
[Unity] Android Plugins 제작하기  (0) 2015.10.27
반응형

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
public Sprite TakeHiResShot(){
        string date = System.DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss");
        string myFilename = "myScreenshot_"+date+".png" ;
        // debugText.text = ": " + myFilename;
        string myDefaultLocation = Application.persistentDataPath + "/" + myFilename;
        //EXAMPLE OF DIRECTLY ACCESSING THE Camera FOLDER OF THE GALLERY
        //string myFolderLocation = "/storage/emulated/0/DCIM/Camera/";
        //EXAMPLE OF BACKING INTO THE Camera FOLDER OF THE GALLERY
        //string myFolderLocation = Application.persistentDataPath + "/../../../../DCIM/Camera/";
        //EXAMPLE OF DIRECTLY ACCESSING A CUSTOM FOLDER OF THE GALLERY
        string myFolderLocation = "/storage/emulated/0/DCIM/Xmas_Friends/";
        string myScreenshotLocation = myFolderLocation + myFilename;
        //ENSURE THAT FOLDER LOCATION EXISTS
        if(!System.IO.Directory.Exists(myFolderLocation)){
            System.IO.Directory.CreateDirectory(myFolderLocation);
        }
        
        
        //TAKE THE SCREENSHOT AND AUTOMATICALLY SAVE IT TO THE DEFAULT LOCATION.
        
        //  캔버스 포함 전체 스크린샷!!
        //  Application.CaptureScreenshot(myScreenshotLocation);
        //
        //
        //
        
        
        
        //  캔버스 제외 카메라에 보이는 부분만 스크린 샷!!
        RenderTexture rt = new RenderTexture(resWidth, resHeight, 24);
        _camera.targetTexture = rt;
        Texture2D screenShot = new Texture2D(resWidth, resHeight, TextureFormat.RGB24, false);        
        Rect rec = new Rect(0, 0, screenShot.width, screenShot.height);        
        _camera.Render();
        RenderTexture.active = rt;
        screenShot.ReadPixels(new Rect(0, 0, resWidth, resHeight), 0, 0);
        screenShot.Apply();
        
        TempImage = Sprite.Create(screenShot, rec, new Vector2(0,0),.01f);
        
        _camera.targetTexture = null;
        RenderTexture.active = null; // JC: added to avoid errors
        Destroy(rt);
        
        byte[] bytes = screenShot.EncodeToPNG();
        System.IO.File.WriteAllBytes(myScreenshotLocation, bytes);
        
        
        
        // 안드로이드 갤러리, 사진첩 업데이트 부분
        // 요거 안하면 "내파일" 에서는 보이지만 갤러리 및 사진첩 어플에서는 보이지 않는 문제가 생김!!!  
 
 
        //MOVE THE SCREENSHOT WHERE WE WANT IT TO BE STORED
        //  System.IO.File.Move(myDefaultLocation, myScreenshotLocation);
 
        //REFRESHING THE ANDROID PHONE PHOTO GALLERY IS BEGUN
        AndroidJavaClass classPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
        AndroidJavaObject objActivity = classPlayer.GetStatic<AndroidJavaObject>("currentActivity");
        AndroidJavaClass classUri = new AndroidJavaClass("android.net.Uri");
        // "android.intent.action.MEDIA_SCANNER_SCAN_FILE" <--- 요거 햇갈림.. 원래 찾은건 "android.intent.action.MEDIA_MOUNTED" 요렇게 하라고 나와있는데 안되서 저렇게 하니 됨.
        AndroidJavaObject objIntent = new AndroidJavaObject("android.content.Intent", new object[2]{"android.intent.action.MEDIA_SCANNER_SCAN_FILE", classUri.CallStatic<AndroidJavaObject>("parse", "file://" + myScreenshotLocation)});
        objActivity.Call ("sendBroadcast", objIntent);
        // debugText.text = "Complete! - " + myScreenshotLocation;
        //REFRESHING THE ANDROID PHONE PHOTO GALLERY IS COMPLETE
 
        //AUTO LAUNCH/VIEW THE SCREENSHOT IN THE PHOTO GALLERY!!!
        // Application.OpenURL(myScreenshotLocation);
        //AFTERWARDS IF YOU MANUALLY GO TO YOUR PHOTO GALLERY,
        //YOU WILL SEE THE FOLDER WE CREATED CALLED "myFolder"
        // count++;
        
        return TempImage;
    }

 

Application.CaptureScreenshot(myScreenshotLocation);
요 함수로 간단하게 될 줄 알았던 스크린샷이 문제가 생겼다.
파일까지 저장이 잘 되지만 갤러리나 사진첩에서 해당 이미지가 업데이트 되지 않는 문제가 생긴다. 강제로 업데이트를 해줘야하는데 위 코드 하단에 보이는 것 처럼 해주면 된다.

참고 : http://answers.unity3d.com/questions/200173/android-how-to-refresh-the-gallery-.html

반응형
저작자표시

'unity C#' 카테고리의 다른 글

[Unity] Application.LoadLevel 사용시 fadeIn fadeOut 효과  (0) 2016.01.14
[Unity] Vector3 position 여러 타겟일때 중점 찾기 Camera  (0) 2016.01.12
[Unity] Bitmap Drawing API 사용해보기  (1) 2015.11.11
[Unity] Android Plugins 제작하기  (0) 2015.10.27
[Unity] x,y 좌표로 각도 구해서 이미지 돌리기  (0) 2015.10.27
반응형

에셋스토어에 Bitmap Drawing 이라고 검색하면 무료로 올라와있다.
텍스쳐에 실시간으로 원하는 그림을(?) 그릴 수 있게 도와주는 API이다.
사용법은 에셋을 Import시키고 Example파일을 참고하면된다.

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
using UnityEngine;
using ProtoTurtle.BitmapDrawing;
 
public class BitmapDrawHandler : MonoBehaviour {
 
Material material;
Texture2D texture;
int num = 5;
Color color;
Color color2;
Vector2 tempPos;
int tempY;
int tempX;
ModelHandler model;
 
void Start () {
model = GameObject.Find("Model").GetComponent<ModelHandler>();
init();
}
void init(){
material = GetComponent<Renderer>().material;
texture = new Texture2D(model.Width,model.Height, TextureFormat.RGB24, false);
texture.wrapMode = TextureWrapMode.Repeat;
material.SetTexture(0, texture);
}
public void Draw(Vector2 startPos, Vector2 endPos){
texture.DrawLine(startPos, endPos, Color.black);
texture.Apply();
}
void FixedUpdate () {
color = new Vector4(Random.RandomRange(0.2f,0.3f),Random.RandomRange(0,1f),Random.RandomRange(0,1),1);
color2 = new Vector4(Random.RandomRange(1,1),Random.RandomRange(1,1),Random.RandomRange(1,1f),1f);
int x = Random.RandomRange(0,model.Width);
int y = Random.RandomRange(0,model.Height);
texture.DrawFilledCircle(x,y,Random.RandomRange(10,20), color);
texture.DrawFilledCircle(x,y,Random.RandomRange(5,10), color2);
texture.Apply();
//  tempX = Random.RandomRange(0,width);
//  tempY = Random.RandomRange(0,width);
//  texture.DrawFilledCircle(tempX,tempY,Random.RandomRange(10,300), color2);
//  texture.DrawFilledCircle(tempX,tempY,Random.RandomRange(10,400), color2);
}
}
 

 

반응형
저작자표시

'unity C#' 카테고리의 다른 글

[Unity] Vector3 position 여러 타겟일때 중점 찾기 Camera  (0) 2016.01.12
[Unity] android screenshot 갤러리 갱신 업데이트 방법  (0) 2016.01.12
[Unity] Android Plugins 제작하기  (0) 2015.10.27
[Unity] x,y 좌표로 각도 구해서 이미지 돌리기  (0) 2015.10.27
[Unity] EventSystem설정 터치 감도 조절  (4) 2015.10.26
반응형

[요약]

1. Eclipse 에서 안드로이드 프로젝트 세팅

2. Java 코드작성 및 jar파일로 Exporting

3. AndroidManifest.xml 수정

4. Unity 프로젝트 생성 및 코드작성

 

 

 
 
 
1. Eclipse 에서 안드로이드 프로젝트 세팅하기
 
– file>new>Project 를 눌러 들어간 후
 
Android Application Project를 선택 후 Next 버튼을 누름.
 
Application Name은 원하는 이름으로 넣고,
마지막 Theme는 사용하지 않으므로 None으로 선택한다.
 
Create custom launcher icon 및 Create activity 둘다 체크 해제한다.
 
src폴더에서 마우스 우클릭 후
 
 
package 이름을 맞춰서 작성해준다.
 
 
작성한 페키지 네임에서 마우스 우클릭후 클래스를 만든다.
 
 
 
Unity3D와 연결을 위해서는 유니티에서 제공하는 Classes.jar파일을 라이브러리에 넣어줘야함.
Unity.app 우클릭 후 패키지보기 클릭.
위치는 아래와 같다.(5.1.X 기준)
 
classes.jar 파일을 복사해서 만들어놓은 아래에 넣어줌.
 
프로젝트에서 우클릭 Properties로 들어가 Java Build Path > Libraries 탭으로 이동한다.
 
우측에 보이는 Add JARs…을 눌러 아까 복사한 파일을 뷸드패스에 추가한다.
 
 
 
 
2. Java 코드작성 및 jar파일로 Export.
 
기본적으로 유니티와 연결하기 위해 UnityPlayerActivity를 Extends해주고,
원하는 펑션을 만든다.
아래는 토스트팝업을 띄우는 코드를 작성함.
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.hnine.softkeyane;
import android.os.Bundle;
import android.widget.Toast;
import com.unity3d.player.UnityPlayer;
import com.unity3d.player.UnityPlayerActivity;
 
public class SoftKeyANE extends UnityPlayerActivity{
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }
  
    public void OpenToastMSG(final String strFromUnity){
         runOnUiThread(new Runnable() {
                      @Override  
             public void run() {
                 Toast.makeText(UnityPlayer.currentActivity.getApplicationContext(), strFromUnity, Toast.LENGTH_SHORT).show();  
             }
               });
    }
}

 

코드작성이 끝났다면 src폴더 위에서 우클릭 후 Export를 눌러준다.
 
Java > JAR file를 선택해 준다
위사진처럼 세팅후 적당한 곳에 파일을 저장한다.
 
 
 
3. AndroidManifest.xml 수정
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.hnine.softkeyane"
    android:versionCode="1"
    android:versionName="1.0" >
 
    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="21" />
        
     <supports-screens
        android:anyDensity="true"
        android:largeScreens="true"
        android:normalScreens="true"
        android:smallScreens="true"
        android:xlargeScreens="true" />
 
    <application
        android:allowBackup="true"
        android:icon="@drawable/app_icon"
        android:label="@string/app_name" >
        <activity
            android:name="com.hnine.softkeyane.SoftKeyANE"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        
        <activity
            android:name="com.unity3d.player.UnityPlayerNativeActivity"
            android:label="@string/app_name">
            <meta-data android:name="unityplayer.UnityActivity" android:value="true" />
            <meta-data android:name="unityplayer.ForwardNativeEventsToDalvik" android:value="false" />
        </activity>
        
    </application>
 
</manifest>

 

일단 저장해 두었던 jar파일과 함께 같은곳에 저장함.
 
 
 
 
 
4. Unity 프로젝트 생성 및 코드작성
 
 
새프로젝트를 만들어서 그림과같이 폴더를 생성한 후 앞서 만들었던 jar파일과 수정한 AndroidManifest.xml파일을 복사해 넣는다.
 
Build Settings에 들어가서 Platform을 Android로 바꿔준 후
Player Settings로 들어가서 Bundle Identifier를 Java파일 작성 시 Package name과 똑같이 맞춰준다.
 
 
 
AndroidManager.cs 파일을 만들어 다음과같이 작성한다.
 
 
 
 
 
C#
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using UnityEngine;
using System.Collections;
 
public class AndroidManager : MonoBehaviour {
 
    private AndroidJavaObject curActivity;
 
    static AndroidManager _instance;
 
    public static AndroidManager GetInstance()
    {
        if (_instance == null)
        {
            _instance = new GameObject("AndroidManager").AddComponent<AndroidManager>();
        }
        return _instance;
    }
 
    void Awake()
    {
        AndroidJavaClass jc = new AndroidJavaClass ("com.unity3d.player.UnityPlayer");
        curActivity = jc.GetStatic<AndroidJavaObject> ("currentActivity");
    }
 
    //Native Java Function Call
    public void AndroidCall(string strFuncName, string strTemp)
    {
        if (curActivity == null)
            return;
 
        curActivity.Call (strFuncName, strTemp);
    }
}

 

사용법은 요렇게 사용하면됨.
 
AndroidManager.GetInstance().AndroidCall(“OpenToastMSG”,”Hello World!”);

 

반응형
저작자표시

'unity C#' 카테고리의 다른 글

[Unity] android screenshot 갤러리 갱신 업데이트 방법  (0) 2016.01.12
[Unity] Bitmap Drawing API 사용해보기  (1) 2015.11.11
[Unity] x,y 좌표로 각도 구해서 이미지 돌리기  (0) 2015.10.27
[Unity] EventSystem설정 터치 감도 조절  (4) 2015.10.26
[Unity] Hashtable > ArrayList > JsonData  (0) 2015.10.26
반응형

using UnityEngine; 
using UnityEngine.EventSystems; 
using DG.Tweening;   

public class WheelHandler : MonoBehaviour, IPointerDownHandler, IPointerUpHandler, IDragHandler { 	 	
    RectTransform ImgRectTransform;   	
    
    void Start () { 		
        ImgRectTransform = GameObject.Find("Canvas/Wheel/ImageR").GetComponent(); 	
    } 	 	
    
    public void OnPointerDown(PointerEventData e){ 		
        rotateImage(e.position); 	
    } 	 	
    
    public void OnPointerUp(PointerEventData e){ 		
        rotateImage(e.position); 	
    } 	 	
    
    public void OnDrag(PointerEventData e){ 		
        rotateImage(e.position); 	
    } 	 	
    
    protected void rotateImage( Vector2 value ){ 		
        float _x = value.x - Screen.width/2; 		
        float _y = value.y - Screen.height/2; 		
        float _R; 		 		
        if(_x > 0){ 			
            _R = (Mathf.Atan(_y/_x) * Mathf.Rad2Deg); 		
        }
        else
        { 			
            _R = (Mathf.Atan(_y/_x) * Mathf.Rad2Deg) + 180; 		
        } 		 		
        
        ImgRectTransform.DORotate(new Vector3(0f,0f,_R),0.1f,RotateMode.Fast); 		 	
    } 
}

 

반응형
저작자표시

'unity C#' 카테고리의 다른 글

[Unity] Bitmap Drawing API 사용해보기  (1) 2015.11.11
[Unity] Android Plugins 제작하기  (0) 2015.10.27
[Unity] EventSystem설정 터치 감도 조절  (4) 2015.10.26
[Unity] Hashtable > ArrayList > JsonData  (0) 2015.10.26
[Unity] 리스트 재 정렬하기 list resorting  (0) 2015.10.26

+ Recent posts

티스토리툴바