블로그 이미지
Every unexpected event is a path to learning for you.

카테고리

분류 전체보기 (2731)
Unity3D (814)
Programming (474)
Server (33)
Unreal (4)
Gamebryo (56)
Tip & Tech (228)
협업 (57)
3DS Max (3)
Game (12)
Utility (136)
Etc (96)
Link (32)
Portfolio (19)
Subject (90)
iOS,OSX (51)
Android (14)
Linux (5)
잉여 프로젝트 (2)
게임이야기 (3)
Memories (20)
Interest (38)
Thinking (38)
한글 (30)
PaperCraft (5)
Animation (408)
Wallpaper (2)
재테크 (18)
Exercise (3)
나만의 맛집 (3)
냥이 (10)
육아 (16)
Total
Today
Yesterday
03-29 07:22

Here are two small tricks that can help if you’re making an isometric 2D game in Unity. Ok, so not actually isometric, but that’s the term we’re used to in videogames, so we’ll go with it. These are quite basic and if you’re working on such a game you’ve probably already tackled them your own way. This is our take on it, hopefully it’s useful to someone.

Sprite Ordering

Normally in a 2D game there is no concept of depth, so if you simply place the sprites in the world, you’ll most likely have objects appearing in the wrong order than what you’d expect in an isometric game.

 

Thankfully Unity exposes Sorting Layer and Order In Layer properties for Renderers.
A quick fix is to set the value of Order in Layer to depend on the Y position of the object.

 

[ExecuteInEditMode]
[RequireComponent(typeof(Renderer))]
public class DepthSortByY : MonoBehaviour
{

    private const int IsometricRangePerYUnit = 100;

    void Update()
    {
        Renderer renderer = GetComponent();
        renderer.sortingOrder = -(int)(transform.position.y * IsometricRangePerYUnit);
    }
}

This solves the problem for the simplest case, when we assume all objects rest on the ground.

 

Let’s assume we want to have an object that is above the ground in the world, like placing a bird house on that tree. Just trying to place it in the world will treat the pivot of the object as being at ground level, with no way to both place it at a proper height and sort it correctly.

 

There are several options for this. Just to get it out of the system, the first option is to add empty space to the texture below the bird house to make sure the pivot is at ground level (in Unity, the pivot can’t be outside of the sprite). This is baaaad! This is wasting texture space, and all instances of that object will need to be at the same height in the game. There are other, less insane, options.

One is having a height property in the DepthSortByY behavior and subtract it from transform.position.y when computing the sorting order.
Another solution (which we went with) is allowing the DepthSortByY behavior to make the depth computation based on another object’s transform. This way, the objects will be considered to be at the same point in space as their target and they’ll have the same depth order, even if they’re at different Y positions in the scene. In the bird house example, the bird house uses the tree’s world position for its depth computations.
This solution works better for our game, because it allows artists to move the item freely while staying at the depth (and not have to deal with editing the “height” parameter). And mainly because all the gameplay takes place in the ground’s 2D plane anyway so all objects are guaranteed to have a root object that has the ground position. In your own game, it might be easier to just use the first option.

[ExecuteInEditMode]
[RequireComponent(typeof(Renderer))]
public class IsometricObject : MonoBehaviour
{
   private const int IsometricRangePerYUnit = 100;
   
   [Tooltip("Will use this object to compute z-order")]
    public Transform Target;
    
    [Tooltip("Use this to offset the object slightly in front or behind the Target object")]
    public int TargetOffset = 0;
    
    void Update()
    {
        if (Target == null)
            Target = transform;
        Renderer renderer = GetComponent();
        renderer.sortingOrder = -(int)(Target.position.y * IsometricRangePerYUnit) + TargetOffset;
    }
}

This is how this example is set up in Unity:

The birdhouse references the tree for its depth.

 

And this is how it behaves in practice:

 

Ground Projection

For certain visual elements and effect, we wanted them to look properly projected on the ground, but also not spend too much time on making art for them. The ‘isometric’ view of the game means that anything that is horizontally on the ground should look squashed vertically.
For simple sprites, this is quite easy. Just draw them directly with the correct perspective and place them in the game.

Things get more complicated when you need something that should be able to rotate in any direction. Like something to show the direction the character is moving in, or some visual effect sweeping the ground towards your attacking direction. Especially if these are things that are animated, drawing them manually for all possible orientations is out of the question (or so the artists claim).

Our solution is: the artists draw and animate these effects as if viewed top-down, and the programmers take care of transforming them at runtime to look as if they were projected on the ground. Without any transformation, just taken from the artists and placed in the game rotating them to match the player’s direction they look like below.

 

We need to squash them vertically. For a sprite that doesn’t rotate, just scaling on the Y dimension does the job. But for a rotating sprite this doesn’t work, and it’s even worse for animations. The first thing we tried was a custom shader that transformed the vertices in the local space to squash them vertically (naturally, we went with the most complex solution first), but this needed to break batching to work properly with all sprites and animations. Or I was just bad at writing that shader, maybe…

The final solution is absurdly simple. Just rotate the object around the X axis, and it works!
However, we also wanted to:

  • apply the rotation automatically and consistently, and not have to remember or care about setting the X component of the rotation ourselves
  • be able to set the Z component of the rotation (to make the effect rotate towards any game world direction)
  • not have to visit all ‘ground projected’ effects when changing the amount of squashing

Basically, the game should not have to know that a rotation on X axis is happening. If an object has the ProjectOnGround behavior attached, it should just draw properly without additional effort. So we do the math just before rendering, and restore the rotation to its normal value right after. This hides the rotation around the X axis from the rest of the code.

[ExecuteInEditMode]
    public class ProjectOnGround : MonoBehaviour
    {
        private Quaternion savedRotation;

        // called before rendering the object        
        void OnWillRenderObject()
        {
            savedRotation = transform.rotation;
            var eulers = transform.rotation.eulerAngles;
            transform.rotation = Quaternion.Euler(Constants.Isometric.PerspectiveAngle, eulers.y, eulers.z);
        }

        //called right after rendering the object
        void OnRenderObject()
        {
            transform.rotation = savedRotation;
        }
    }

Simple and easy. Too bad I wasted time trying to write a shader for this. The result looks good and we can simple ‘project’ any object by just adding this behavior to it.

 

 

 

[출처] https://breadcrumbsinteractive.com/two-unity-tricks-isometric-games/

 

Two Unity tricks for isometric games - Breadcrumbs

Here are two small tricks that can help if you’re making an isometric 2D game in Unity. Ok, so not actually isometric, but that’s the term we’re used to in videogames, so we’ll go with it. These are quite basic and if you’re working on such a gam

breadcrumbsinteractive.com

 

반응형
Posted by blueasa
, |

Hidden Assets

During the import process, Unity ignores the following files and folders in the Assets folder (or a sub-folder within it):

  • Hidden folders.
  • Files and folders which start with ‘.’.
  • Files and folders which end with ‘~’.
  • Files and folders named cvs.
  • Files with the extension .tmp.

This prevents importing special and temporary files created by the operating system or other applications.

 

[출처] https://forum.unity.com/threads/exclude-files-or-folders-from-importing.48090/

 

Exclude files or folders from importing

Is there any way to exclude psd, jpg, max file (or whole folder) in Assets folder from being imported to Unity as texture or model? I keep my...

forum.unity.com

 

[참조] https://docs.unity3d.com/Manual/SpecialFolders.html?_gl=1*f8onwh*_ga*MTUzMjkzMTA0MC4xNjIyNzEzNDM4*_ga_1S78EFL1W5*MTYyNDg3MTc4MS41LjEuMTYyNDg3MjE4OC4xMA..&_ga=2.190280226.821848530.1624841162-1532931040.1622713438 

 

Unity - Manual: Special folder names

Reusing assets between projects How do you use documentation throughout your workflow? Share your experience with us by taking this survey. Special folder names You can usually choose any name you like for the folders you create to organise your Unity proj

docs.unity3d.com

 

반응형
Posted by blueasa
, |

[에러 메시지]

An asset is marked with HideFlags.DontSave but is included in the build:
Asset: 'Library/unity editor resources'
Asset name: Font Material
(You are probably referencing internal Unity data in your build.)
UnityEditor.BuildPlayerWindow:BuildPlayerAndRun()

 

[해결방법]

유니티 자체 폰트 중 Arial을 제외한 다른 자체 폰트를 쓰면 안된다고 한다.

내부 폰트 사용하는 부분을 찾아서 다른걸로 교체하자.

 

 

[출처] lhh3520.tistory.com/168

 

[Unity3D] Asset: 'Library/unity editor resources' 에러

유니티를 빌드 하다보면 아래같은 에러가 날 때가 있는데.. 갑자기 뜬금없이 나니까 당황스럽네요. 여기저기 찾아보니 해결방법은 Unity Font 중에 Arial 을 제외한 다른 폰트 를 쓰면 안됩니다. UI

lhh3520.tistory.com

 

반응형
Posted by blueasa
, |


image.png

들어가면서

socket.io

웹 환경에서는 클라이언트인 브라우저와 서버 간에 푸쉬나 실시간 데이터를 처리하는데 여러 가지 방법을 활용했습니다. 그중에 Ajax를 이용한 polling, Long polling과 Streaming의 특징은 다음 그림과 같이 비교할 수 있습니다.

image.png
출처 : https://blogs.oracle.com/theaquarium/entry/slideshow_example_using_comet_dojo

위와 같은 방식을 활용하다가 나온 표준이 Websocket입니다. Websocket은 기존에 게임 개발자들이 활용하고 있던 TCP socket과 비슷하게 데이터를 주고 받을 수 있으며 Polling보다 자유롭게 데이터를 주고 받을 수 있게 되었습니다. Webocket에 대해 좀더 자세한 내용을 원하시면 여기 링크(https://ko.wikipedia.org/wiki/웹소켓) 를 참조 부탁드립니다. 하지만 이 좋은 Websocket의 단점은 지원하는 브라우저가 없을 수 있다는 점이 입니다. 이런 단점을 보완 하고자 브라우저와 상관 없이 웹에서 실시간으로 데이터를 처리 할수 있게 도와주는 것이 바로 socket.io입니다. socket.io(http://socket.io)는 Guillermo Rauch에의해 LearnBoost라는 회사가 개발했으며 MIT 라이선스의 오픈소스입니다.

socket.io는 WebSocket, FlashSocket, JSONP과 Long Polling을 하나로 묶어 브라우저에서 Websocket을 지원하지 않더라도 실시간 데이터처리를 돕습니다. 다양한 브라우저에서 데이터를 처리하기 위한 방법 뿐만 아니라 데이터를 주고 받기 위한 메세지 규약, 연결 유지를 위한 핑퐁 등과 같이 socket 연결을 위해 기본으로 구현해야할 부분까지 처리가 되어있기 때문에 서비스 개발자는 실시간 데이터 처리만 집중할 수 있습니다. socket.io의 프로토콜 정의는 링크 https://github.com/socketio/socket.io-protocol와 https://github.com/socketio/engine.io-protocol 참조 하시면 됩니다.

socket.io-Client

요 근래 게임에서도 실시간으로 데이터를 처리 하기 위해 Websocket을 많이 활용하는 추세 입니다. 왜냐하면 TCP socket보다 단순하게 구현할 수 있기 때문입니다. 실제로 Unity3d에서 WebGL로 빌드 할 때에도 데이터를 주고 받는 방법으로 Websocket을 이용하고 있습니다. socket보다 구현하기 쉬운 Websocket도 사실 데이터처리가 용의할 뿐 연결을 체결하거나 유지하는 등의 네트워크 레이어는 개발자가 직접 구현해야 합니다. 하지만 socket.io를 이용하면 연결과 기본적인 프로토콜이 구현되어 있기 때문에 개발자는 컨텐츠 데이터를 주고 받는데만 집중할 수 있습니다.

socket.io는 다양한 언어를 지원합니다. Javascript는 물론이고, Java, Swift와 CPP을 지원합니다. 지원하는 언어는 아래와 같습니다.

개발 하기까지

우리 회사에는 풋볼데이와 야구9단과 같은 웹 게임을 개발하면서 데이터를 push해주기 위해 socket.io를 이용했습니다. 기존의 socket.io구현체는 Node.js를 활용한 구현체 였지만 우리회사는 JAVA를 활용하여 대용량 트래픽 처리와 보안 인증을 추가한 플랫폼으로 구현했습니다. 해당 플랫폼을 사내 공용 플랫폼화 하여 웹 게임 뿐만 아니라 다른 서비스에도 적용하였고, 웹과 네이티브 앱간의 데이터 통신하는데 활용하고 있습니다.

기존의 socket.io 클라이언트 들은 다양한 네이티브 언어를 지원하고 있으나 게임개발에 많이 활용되고 있는 unity3d는 지원하지 않습니다. 우리는 우리의 플랫폼을 게임에도 활용하여 게임 개발자들에게 데이터 처리를 위해 네트워크를 개발하는 수고를 덜어주고 싶었습니다. 서버는 우리 회사의 플랫폼도 있고 오픈소스인 socket.io node.js용 서버도 있으니 클라이언트만 있다면 게임 개발자들도 쉽게 개발 할수 있을 것 같았습니다. 하지만 기존의 unity3d용 라이브러리들은 0.9버전이거나 유지 보수가 되지 않아서 우리가 직접 socket.io-Client Unity3D 라이브러리를 개발하게 되었습니다.

socket.io 사용법

실제로 Node.js + socket.io-Client Unity3D를 이용하여 구현된 샘플 코드를 살펴보면서 socket.io 사용법을 소개하겠습니다. 서버/클라이언트 코드로 구성되며 서버 코드는 socket.io 공식 홈페이지에서 발췌/변경하였습니다. socket.io 공식 홈페이지는 아래 링크를 확인해주세요.
socket.io 공식 홈페이지

추가로 Node.js로 직접 서버 코드를 실행해보고 싶으신 분들은 아래 링크를 참조하여서 서버 개발 환경 셋팅을 할 수 있습니다.
Node.js and Visual Studio Code End to End

예제를 구현하기 위한 소스는 아래 링크에서 찾아 보실 수 있습니다.

Connect to Server

첫번째 해야할 것은 역시나 컨넥션을 맺는 것입니다. 서버는 우선 HTTP 서버를 오픈해야합니다. 이는 socket.io 클라이언트가 최초엔 Polling 모드로 접속을 시도하도록 구현되어 있기 때문입니다.

서버 코드 [https://github.com/nhnent/socket.io-client-unity3d/blob/master/Assets/__Sample/Server~/connection.js]
var app = require('http').createServer(handler)
var fs = require('fs');

app.listen(4444);

function handler (req, res) {
  fs.readFile(__dirname + '/index.html',
  function (err, data) {
      if (err) {
          res.writeHead(500);
          return res.end('Error loading index.html');
      }

      res.writeHead(200);
      res.end(data);
  });
}

// socket.io 스타트
var io = require('socket.io')(app);

// 클라이언트 컨넥션 이벤트 처리
io.on('connection', function (socket) {
  console.log('Hello, socket.io~');
});

Socket.io가 시작되는 것은 'socket.io' 모듈을 가져올 때, 원샷에 처리가 됩니다. 이 때, 인자값으로 HTTP 서버의 인스턴스 (app 변수)를 추가해주면 HTTP 서버의 주소로 Socket.io가 Bind되면서 자동으로 Listen을 시작합니다. 이 때, 리턴하는 io 변수는 일종의 매니저 객체로써 이를 통해서 실제 세션에 해당하는 socket 객체를 획득할 수 있습니다. io.on() 메소드에서 'connection'이라는 이벤트를 핸들링하도록 구현했고, 클라이언트에서 컨넥션이 완료되었을 때, 콜백 함수를 통해서 socket을 획득할 수 있습니다. socket은 일종의 세션 객체라고 생각해도 무방합니다. socket을 통해서 앞으로 각종 패킷을 Send/Receive하게 됩니다.

클라이언트 코드 [https://github.com/nhnent/socket.io-client-unity3d/blob/master/Assets/__Sample/Client/Src/Connection.cs]
using UnityEngine;
using socket.io;

namespace Sample {

    public class Connection : MonoBehaviour {

        void Start() {
            // 접속 Url
            var serverUrl = "http://localhost:4444";

            // 서버로 접속 시도~
            var socket = Socket.Connect(serverUrl);

            // 접속 완료 이벤트 처리
            socket.On("connect", () => {
                Debug.Log("Hello, socket.io~");
            });
        }

    }

}

클라이언트는 socket.io.Socket 클래스의 Connect() 메소드를 호출합니다. 이 때 인자값으로 서버의 Url을 입력합니다. 접속이 성공하면, socket 변수를 리턴하고 서버와 동일하게 각종 패킷을 Send/Receive하게 됩니다. 예제 코드에서는 'connect' 이벤트를 캐치하여 웰컴 메세지를 출력하도록 구현해보았습니다.

Event 핸들링

socket.io는 Event 기반으로써 모든 통신의 처리는 'Event 등록 + Callback 함수 구현'의 형식으로 구현됩니다. Event를 Send하는 메소드는 Emit(), 그리고 Event를 Receive하는 메소드는 On()입니다. 아래 예제를 보면서 좀 더 자세히 살펴보겠습니다.

서버 코드 [https://github.com/nhnent/socket.io-client-unity3d/blob/master/Assets/__Sample/Server~/events.js]
// HTTP 서버 코드는 생략 (...)

// socket.io 스타트
var io = require('socket.io')(app);

// 클라이언트 컨넥션 이벤트 처리
io.on('connection', function (socket) {

    // 'news' 이벤트 send
    socket.emit('news', { hello: 'world' });

    // 'my other event' 이벤트 receive
    socket.on('my other event', function(data) {
        console.log(data);
    });

});
클라이언트 코드 [https://github.com/nhnent/socket.io-client-unity3d/blob/master/Assets/__Sample/Client/Src/Events.cs]
using UnityEngine;
using socket.io;

namespace Sample {

    public class Events : MonoBehaviour {

        void Start() {
            var serverUrl = "http://localhost:4444";
            var socket = Socket.Connect(serverUrl);

            // "news" 이벤트 처리 Receive
            socket.On("news", (string data) => {
                Debug.Log(data);

                // "my other event" 이벤트 Send
                socket.Emit(
                    "my other event",       // 이벤트명
                    "{ \"my\": \"data\" }"  // 데이터 (Json 텍스트)
                    );
            });
        }

    }

}

2개의 이벤트를 정의하여 서버와 클라이언트 간의 패킷 송수신을 구현했습니다. 서버는 'news' 이벤트를 Send하고 'my other event'를 Receive합니다. 클라이언트는 반대입니다.

실행 결과
  • 서버
    image.png
  • 클라이언트
    image.png

Emit() 메소드

Send를 담당하는 Emit() 메소드는 다음과 같은 형식을 같습니다.

public void Emit(string evtName, string data);
  • Emit() 파라메터
evtNamedata
이벤트 이름이벤트 데이터 (주로 Json 객체)

On() 메소드

Receive를 담당하는 On() 메소드의 정의는 다음과 같습니다.

public void On(string evtName, Action<string> callback);
  • On() 파라메터
evtNamecallback
이벤트 이름이벤트 핸들러 함수

System Event

Emit()과 On() 메소드에서 선언한 이벤트 이름 중 일부 문자열은 시스템 예약어이므로 사용을 금지합니다. 서버 용 시스템 이벤트는 아래 링크에서 확인이 가능합니다.

[https://socket\.io/docs/server\-api/\]\(socket\.io Server API)

여기서는 클라이언트 용 시스템 이벤트만 정리해보겠습니다.

이벤트 이름콜백 파라메터비고
connect없음접속 완료
connectTimeOut없음시간 초과로 인한 접속 실패
reconnectAttempt없음재접속 시도
reconnectFailed없음재접속 실패
reconnectint (재접속 횟수)재접속 완료
reconnectingint (재접속 횟수)재접속 중
connectErrorException접속 실패
reconnectErrorException재접속 실패

콜백 파라메터를 기준으로 On() 메소드 호출 형식이 바뀌게 됩니다. 예를 들어 'reconnect' 이벤트를 핸들링하고 싶다면 다음과 같이 코드를 작성해야 합니다.

socket.On("reconnect", (int attempt) => {
    Debug.LogFormat("Reconnected after {0} trials, attempt);
});

Event Ack

이번엔 이벤트를 Send하고 이에 대한 응답을 Receive하는 방법을 알아보겠습니다.

서버 코드 [https://github.com/nhnent/socket.io-client-unity3d/blob/master/Assets/__Sample/Server~/acks.js]
// HTTP 서버 코드는 생략 (...)

// socket.io 스타트
var io = require('socket.io')(app);

// 클라이언트 컨넥션 이벤트 처리
io.on('connection', function (socket) { 

   socket.on('ferret', function (name, fn) {
        // 'woot' 문자열을 Ack 메세지로 보냄
        fn('woot');
    }); 
});
클라이언트 코드 [https://github.com/nhnent/socket.io-client-unity3d/blob/master/Assets/__Sample/Client/Src/Acks.cs]
using UnityEngine;
using socket.io;

namespace Sample {

    public class Acks : MonoBehaviour {

        void Start() {
            var serverUrl = "http://localhost:4444";
            var socket = Socket.Connect(serverUrl);

            socket.On("connect", () => {

                // "ferret" 이벤트 Send
                socket.Emit(
                    "ferret", "\"toby\"", 
                    (string ackData) => { Debug.Log(ackData); } // 3번째 인자로 콜백을 셋팅하면 Ack 모드로 동작하며 Ack 시에 콜백이 호출됨
                    );
            });
        }

    }

}

앞서 소개한 Event 핸들링 예제와 달라진 점은 클라이언트 코드에서 Emit() 메소드에 3번째 인자로 콜백을 추가한 것입니다. 이렇게 호출하게 되면 Ack 모드로 Emit() 메소드가 동작하게 됩니다. 위의 예제에서는 서버 코드에서 Ack 메시지로 'woot' 문자열을 리턴하였고, 클라이언트는 Ack 콜백에서 'woot' 문자열을 인자값으로 받게 됩니다.

Namespace

하나의 소켓을 논리적인 처리 단위로 구분할 수 있습니다. Multiplexing이라고도 불리는 이러한 패턴을 통해서 하나의 커넥션(소켓 인스턴스)에서 여러 개의 독립적인 코드를 개발할 수 있습니다.

서버 코드 [https://github.com/nhnent/socket.io-client-unity3d/blob/master/Assets/__Sample/Server~/namespace.js]
// HTTP 서버 코드는 생략 (...)

// socket.io 스타트
var io = require('socket.io')(app);

// chat 네임스페이스
var chat = io
  .of('/chat')
  .on('connection', function (socket) {
    chat.emit('a message', { everyone: 'in', '/chat': 'will get' });
    socket.emit('a message', { that: 'only', '/chat': 'will get' });
  });

// news 네임스페이스
var news = io
  .of('/news')
  .on('connection', function (socket) {
    socket.emit('item', { news: 'item' });
  });
클라이언트 코드 [https://github.com/nhnent/socket.io-client-unity3d/blob/master/Assets/__Sample/Client/Src/Namespace.cs]
using UnityEngine;
using socket.io;

namespace Sample {

    public class Namespace : MonoBehaviour {

        void Start() {
            var serverUrl = "http://localhost:4444";

            // news 네임스페이스
            var news = Socket.Connect(serverUrl + "/news");
            news.On("connect", () => {
                news.Emit("woot");
            });
            news.On("a message", (string data) => {
                Debug.Log("news => " + data);
            });
            news.On("item", (string data) => {
                Debug.Log(data);
            });

            // chat 네임스페이스
            var chat = Socket.Connect(serverUrl + "/chat");
            chat.On("connect", () => {
                chat.Emit("hi~");
            });
            chat.On("a message", (string data) => {
                Debug.Log("chat => " + data);
            });
        }

    }

}

서버는 of() 메소드를 통해서 네임스페이스를 선언합니다. 클라이언트는 단순히 Url에 주소를 추가하는 것으로 선언이 가능합니다. 위 예제에선 "http://localhost:4444/chat"과 "http://localhost:4444/news"와 같이 chat과 news 네임스페이스를 선언하였습니다. 그 외에 나머지는 일반적인 이벤트 핸들링과 동일합니다.

실행 결과

image.png

위 예제의 포인트는 클라이언트 코드에서 chat과 news이 모두 'a message' 이벤트를 등록하였지만 오직 chat 소켓만이 'a message' 이벤트를 핸들링하게 되는 점입니다. 네임스페이스로 구분하여 이벤트명을 중복하여 사용하는 것이 가능하다라는 것을 시사하며 이를 통해서 채널 혹은 컨텐츠 개발 스코프마다 각각 네임스페이스르 할당해서 작업한다면 하나의 소켓 컨넥션 안에서도 이벤트 이름의 충돌없이 코드 작성이 가능하게 됩니다.

결론

오랫동안 게임 개발에서는 Socket을 이용한 네트워크를 구현해 왔습니다. 하지만 socket을 이용하여 데이터를 주고 받기 위해서는 네트워크의 연결 유지와 데이터 전송을 위해 너무 많은 노력이 필요합니다. 게임 개발에 있어서 어려운 네트워크 구현을 빼고 컨텐츠 개발에 힘을 쓴다면 더 좋은 게임이 나올 것이라 생각됩니다. 더욱이 웹과 같은 다양한 플랫폼을 지원 하는 게임을 개발하는데 있어 네트워크 레이어마다 개발을 해야한다면 좀더 좋은 게임을 개발할 수 있는시간을 빼앗기게 됩니다. 그래서 우리는 게임 개발자들이 데이터 통신에 많은 시간을 투자하지 않고 게임을 개발 할수 있도록 socket.io를 위한 Unity3d를 MIT라이선스로 공개하기로 했습니다. socket.io-client-unity3d를 활용하여 좀더 컨텐츠 개발에 시간을 투자하고, 하나의 서버 플랫폼을 이용해 다양한 클라이언트 플랫폼을 지원 하는데 도움이 되었으면 좋겠습니다.

해당 라이브러리에 관심이 있으신분들은 https://github.com/nhnent/socket.io-client-unity3d에서 확인 하실 수 있습니다. 또한 참여하시고 싶으신 분들은 https://github.com/nhnent/socket.io-client-unity3d/blob/master/CONTRIBUTING.md를 참조하셔서 참여하여 주시면 감사하겠습니다.


[출처]

https://meetup.toast.com/posts/112



[추가]

socket.io v2.x에서 수정해야 될 내용

https://github.com/nhnent/socket.io-client-unity3d/commit/48b1fb6e743ff2228942a6e08f2eb9a73e1ff2a0


[추가2]

socket.io https 대응 (출처: shmhlove)

https://github.com/shmhlove/Asgardium_Client/tree/develop/Assets/Plugins/socket.io

반응형

'Unity3D > Plugins' 카테고리의 다른 글

[링크] Simple Unity browser  (0) 2019.03.28
[링크] 유니티랑 nodejs 간단 연동 테스트 해보기  (0) 2019.03.08
[링크] iOSPlugin Sample  (0) 2019.01.29
[펌] Unity Excel Importer  (0) 2019.01.03
[링크] Emoji_Extension  (0) 2018.06.07
Posted by blueasa
, |

If you need to execute some long running task on the background in Unity, you may find this tool I just wrote, useful. This is BackgroundWorker for Unity 3D

BackGround Worker for Unity3D

You will only need the class BackgroundWorker

It worth noting that a lot of seemingly background tasks can be implemented with Unity Coroutines. For example using WWW service to send or receive data from a remote server. Or any case where we just wait for a response from a remote computer.

However because coroutines run on the main thread if you really have a long running, not just waiting for response but computing intensely something, you will need to run it on a background thread. Here is how you use this tool:

if (_backgroundWorker != null) _backgroundWorker.CancelAsync();
_backgroundWorker = new BackgroundWorker();

_backgroundWorker.DoWork += (o, a) =>
{
    // executed on background thread
    // do slow running computationaly intense work, check periodically 
    // if (a.IsCanceled) return;
    
    // assign result as 
    // a.Result = a.Argument+"!";
};
_backgroundWorker.RunWorkerCompleted += (o, a) =>
{
    // executed on main thread
    // you can use a.Result
};

_backgroundWorker.RunWorkerAsync(argumetToPassOrNull);

And then on each frame execute:

if (_backgroundWorker != null) _backgroundWorker.Update();

The tool has been tested on Windows, Mac, iPhone, and Android.

This is a sample usage of the BackgroundWorker class.



[출처] http://blog.bodurov.com/Background-Worker-for-Unity3D/

반응형

'Unity3D > Plugins' 카테고리의 다른 글

[펌] Unity Excel Importer  (0) 2019.01.03
[링크] Emoji_Extension  (0) 2018.06.07
[Link] UnityAppNameLocalizationForIOS  (0) 2018.03.27
[에셋] Anti-Cheat Toolkit  (0) 2018.03.06
[펌] UnityIPhoneXSupport  (0) 2017.11.10
Posted by blueasa
, |

[파일]


$NShader.zip



위 파일 설치하면 됨..



[참조]

Ok. Here's small update:
http://www.jostavo.net/NShader.rar (it's a new fork for 2013 by SilentSouls that uses embedded coloring, the one Nims mentioned before)

I've added support of .shader.compute.cginc (sorry just handling not native support, see attach)

*optional* - in VisualStudio go Tools > Extensions and Updates find NShader and uninstall it, reboot studio (it need to be restarted to remove files)
Make sure Visual Studio is closed

Who afraid to download my file, install one from jostavo.net and then create and add .reg:
For future updates:
{af99cc5c-2a8a-3547-b255-896525bc39d1} - is UUID for current build only!

To find one You needed - open NShader.pkgdef and look for:
Or after install go
There will be yours.
 

Attached Files:




[출처] http://forum.unity3d.com/threads/tutorial-how-to-use-nshader-with-unity-shaders.108995/

반응형
Posted by blueasa
, |


Link : http://smilejsu.tistory.com/673

반응형

'Server > Node.js' 카테고리의 다른 글

[Plugin] Node.js Tools for Visual Studio  (0) 2014.07.14
Node.js의 문서의 한글 번역본  (0) 2014.06.21
Node.js  (0) 2014.06.21
Posted by blueasa
, |

화면에 커서를 보이거나 안보이게하기

Screen.showCursor = false;



화면의 가로/세로 크기값

Screen.width

Screen.height



해상도 설정하기

void Awake() {

 Screen.SetResolution(640, 480, true);

}



해상도 정보얻어오기

public Resolution[] resolutions = Screen.resolutions;



커서가 보이지 않고 움직이지 않게하기

Screen.lockCursor = true;



프로그램 종료하기

Application.Quit();



화면 캡쳐하기 (png 파일로만 되는거 같아요. 확실치는 않음 ㅎㅎ)

Application.CaptureScreenshot("Screenshot.png");



씬데이터 로딩 체크하기

 void Update() {

        if (Application.CanStreamedLevelBeLoaded(1))

            Application.LoadLevel(1);

        

    }


 

유니티 오쏘링모드에서 게임이 플레이 중인지 체크하기

Application.isPlaying




웹사이트로 링크걸기

Application.OpenURL ("http://unity3d.com/");



플랫폼(OS) 확인하기

Application.platform



실행중인 디바이스 확인하기(OS체크)

RuntimePlatform.OSXPlayer //맥

RuntimePlatform.WindowsPlayer // 윈도우

RuntimePlatform.WiiPlayer //닌텐도 위(wii)

RuntimePlatform.IPhonePlayer // 아이폰

RuntimePlatform.Android // 안드로이드

RuntimePlatform.XBOX360 // 엑스박스



PS3 //플레이스테이션



반응형
Posted by blueasa
, |

Unity3d 50가지 팁

Unity3D/Tips / 2013. 2. 5. 18:26

출처 원문

http://devmag.org.za/2012/07/12/50-tips-for-working-with-unity-best-practices/

 

 

팁들에 대해서

이 팁들은 모든 프로젝트에 적용 가능하지는 않습니다.

  • 이것들은 3~20명의 인원으로 구성된 작은팀의 프로젝트 경험을 기반으로 합니다.
  • 구조, 재사용성, 명확성, 기타 등등 의 비용은 팀 크기와 프로젝트의 크기에 따라 비용 지불 여부가 결정 됩니다.
  • 많은 팁들은 취향의 문제 입니다.
    (하지만 여기에 나온 여러 팁들은 우열을 가리기 어려울 정도로 좋은 기술들 입니다.)
  • 몇개의 팁은 공식 Unity 개발에 위배 되는 것들입니다. 예를 들면, 몇개의 특수한 인스턴스를 위한 프리팹의 사용은 매우 Unity 에서 싫어하는 방식으로, 비용 또한 상당히 높습니다(이렇게 라도 prefab 들을 사용하는게 나을 때도 있습니다).  그러나 나는 이런 팁들이 미친 짓 같아 보여도 가끔 좋은 결과를 가지고 오는 경우도 보곤 합니다.

Process


1. 자산을 여러 버전으로 나누지 말라. 항상 모든 자산은 오직 한 버전으로 있어야 한다. 만약 절대경로로 프리팹, 씬, 또는 메쉬 등을 분기 하여 만드는 경우 옳은 버전이다. "잘못된" 분기는 임시적 이름으로, 예를들면 밑줄 두개를 접두로 붙이는 경우다. __MainScene_Backup. 프리팹을 분기 하는 경우 분명하게 이름을 명시하는게 안전하게 생성하는 방법이다. (Prefabs 섹션을 참고)

원문

2. 버전 컨트롤을 사용할 경우 각 팀 구성원들은 테스트를 위해 체크 아웃한 프로젝트의 두번째 복사본이 있어야 한다. 변경 후, 두번째 복사본은 clean copy 및 update 를 하고 test 를 해야 한다. 모든 사람들은 clean copy 상태에서 변경을 해야 합니다.

원문

3. 레벨 수정을 위한 외부 레벨 툴을 사용하는걸 고려하라. Unity 는 완벽한 레벨 에디터가 아니다. 예로, 우리는 3D tile 기반의 게임을 위해 레벨 빌드를 TuDee 를 사용하여 만들었으며, 우리는 tile 친화적인 툴을 통해 도움을 받았다 (그리드 가 붙는, 그리고 90 도 로 여러번 회전, 2d 뷰, 빠른 선택). XML 파일을 통한 prefab 초기화는 간단합니다. Guerrilla Tool Development 에 자세한 아이디어가 있습니다.

원문

4. 레벨 저장을 scene 대신 XML 으로 하는걸 고려하라. 이건 훌륭한 기술이다:

  • 이렇게 만들면 각각의 scene 을 다시 만드는게 불필요해 집니다.
  • 이렇게 만들면 보다 빠르게 로딩 합니다(대부분의 객체가 scene 에서 공유되는 경우)
  • 이렇게 만들면 scene 을 합치는게 쉬워집니다.(Unity 의 새로운 text 기반 scene 은 너무 많은 데이터를 포함하고 있어 합치는게 비현실적으로 보입니다)
  • 이렇게 만들면 데이터 레벨 수준에서 관리를 할 수 있습니다.
당신은 여전히 Unity 를 레벨 에디터 로 사용 할 수 있습니다(필요성을 못 느낄경우). 네가 데이터 , 에디터와 레벨 로드 를 실시간으로 처리, 에디터로 부터 레벨 저장을 해야 할 경우 몇몇의 코드는 직렬화 와 역직렬화를 필요로 하게 된다. 너는 아마 또한 객체간 참조를 유지하기 위해 Unity 의 id system 을 모방 해야 할 것입니다.

원문

5. 일반적인 커스텀 inspector 코드를 작성하는 걸 고려하라. 커스텀 inspector 를 작성하는건 매우 간단하나, Unity 의 시스템은 많은 단점을 가지고 있다.

  • 상속을 활용한 방식을 지원하지 않습니다.
  • 당신이 정의 하는 inspector 컴포넌트는 필드 타입 수준에서 구성이 안되며, 오로지 클래스 타입 레벨만 지원합니다. 예 로, 만약 모든 게임 오브젝트가 SomeCoolType 필드타입 이고, inspector 에서 다르게 렌더링 하려 할 경우,당신은 모든 클래스들에 대해서 inspector 를 작성해야 합니다.

당신은 기본적으로 inspector 시스템을 다시 구현함으로써 이러한 문제를 해결 할 수 있습니다. reflection의 몇가지 기술을 사용하여 해결할 수 있으며, 자세한 방법은 문서의 끝에 나와 있습니다.

원문


Scene Organisation

6. scene 폴더를 빈 게임 오브젝트 의 이름으로 사용하라. 당신의 scene 에서 찾고자 하는 오브젝트를 쉽게 찾을수 있도록 구성 할 수 있습니다.

원문

7. 관리하는 prefab 과 폴더 (빈 게임 오브젝트) 를 0 0 0 에 넣습니다. 만약 위치를 명시하지 않은 채 오브젝트의 위치를 사용 하면, 아마 원점에 있을겁니다. 그 방법은, 실행 중 로컬과 월드 공간간의 문제를 줄여줄 수 있으며, 코드는 일반적으로 간단합니다.

원본

8. GUI 컴포넌트의 offset 사용을 최소화 하라. Offset 은 항상 자신의 부모 Component 에서 레이아웃 Component 를 사용해야 합니다. 그들은 조부모(부모의부모)의 위치에 의존해서는 안됩니다. Offset 을 올바르게 표시하기 위해서는 서로를 취소 할 수 없습니다 . 이런 일을 방지하기 위해 기본적으로:

부모 컨테이너가 임의의 위치로  (100, -50) 이고, 자식의 위치가  (10, 10) 이기를 희망 할 경우, 위치 정의를 (90, 60) [relative to parent] 으로 하면 된다.

이 에러는 컨테이너가 invisible 상태일때 공통으로 발생하며, 또는 시각적 표현이 없는 경우에 해당합니다.

원문

9. 당신의 월드 바닥을 y = 0 으로 하라. 이와 같이 하면 오브젝트를 바닥에 생성하는게 쉬워지며, 게임 로직, AI, 물리 등을 2D 공간(이게 적절할 경우)으로 월드에 적용할 수 있습니다.

원문

10. 모든 scene 을 게임 실행 가능하게 만듭니다. 이건 대폭적으로 테스트 시간을 줄일 수 있습니다. 모든 scene 을 실행 가능하게 만들려면 두가지 고려사항이 있습니다:

첫번째로, 이전에 로드해야 하는 scene 의 데이터가 필요로 하는데 사용 할 수 없는 경우, 임시 데이터 를 제공 할 수 있도록 해야 합니다.

두번째로, 생성한 오브젝트는 다음의 scene 과 scene 을 불러오는 사이에 계속 되어야 한다.

myObject = FindMyObjectInScene();
 
if (myObjet == null)
{
   myObject = SpawnMyObject();
}

원문


Art

11. 케릭터와 서있는 오브젝트는 pivot 기반이여 하며, center 중심이어선 안된다 . 
이런식 으로 만들면 보다 쉽게 케릭터와 오브젝트를 바닥에 올려놓을 수 있습니다 . 이것은 또한 게임 로직, AI 와 물리 등이 필요로 하는 경우에 3D 환경에서 2D 같이 제작 할 경우 쉽게 만들 수 있습니다.

원문

12. 제작하는 모든 메시의 바라보는 방향을 일치 합니다(+Z 또는 -Z). 케릭터와 다른 오브젝트들의 메시는 바라보는 방향이 다르게 적용이 됩니다. 바라보는 방향을 통일 시키면 많은 알고리즘들을 쉽게 적용 할 수 있습니다.

원문

13. 시작시 스케일의 규모를 정하도록 한다. 만든 작업물을 임포트 할때 스케일 크기를 1로 하게 되면 그것의 트랜스폼 스케일은 1 1 1 이 된다. 스케일의 비교를 쉽게 하기 위해서 참조 오브젝트(Unity 상자)를 사용 합니다. 게임에 적합한 Unity 단위 비율을 선택하고, 정한것에 충실하도록 합니다.

원문

14. GUI 컴포넌트와 파티클을 수동으로 생성 해야 할 경우 2개의 삼각형으로 된 평면을 사용 합니다. 평면을 Z+ 방향으로 하는게 빌보드와 GUI 를 만드는데 쉽게 합니다.

원문

15. 테스트 작업물 만들기 및 사용

  • 스카이 박스들을 위한 사각형 표기.
  • 그리드(격자).
  • shader 테스트를 위한 다양한 평면 색상: 흰색, 검은색, 50% 회색, 적색, 녹색, 청색, 마젠타, 노랑, 청록색.
  • shader 테스트를 위한 그라데이션: 검은색 에서 흰색, 적색에서 녹색, 적색에서 청색, 녹색에서 청색.
  • 검은색과 흰색으로 된 체커보드(체커판).
  • 부드럽고 거친 노멀맵.
  • 빠른 테스트 scene 설정을 위한 라이팅 을 갖춤(프리팹).

원문

Prefabs

16. 모든 것에 프리팹을 사용하도록 한다.   당신의 scene 에 게임 오브젝트만 있는 경우에는 프리팹이 폴더에 있을 필요는 없습니다. 심지어 한번만 사용 하더라도 고유 객체를 프리팹으로 해야합니다. scene 을 바꾸지 않는 경우 만든것을 수정하는걸 편하게 작업할 수 있습니다. (또 다른 장점은 EZGUI 를 사용하는 경우 신뢰 할만한 스프라이트 아틀라스 를 구축할 수 있습니다.).

원문

17. 특수화된 프리팹은 사용해도 좋지만; 특수화 된 인스턴스는 사용하지 말라. 만약 다신이 두개의 적 타입을 가지고 있는 경우, 그리고 그것들이 프로퍼티만 다른 경우, 속성에 대해 별도의 프리팹을 만들고, 그것을 링크 합니다. 이렇게 하는게 가능한 경우는

  • 한 곳에서 각각의 타입을 변경 할 경우
  • scene 을 변경하지 않고 변경 할 경우

당신이 너무 많은 적 타입을 가지고 있을지라도, 특수화는 여전히 에디터의 인스턴스를 만들어서는 안됩니다. 한가지 대안책은 절차를 따르거나 또는 모든 적들을 기준의 파일 / 프리팹을 사용하는 겁니다. 적들을 구분하는걸 사용하여 하나의 적을 쓰러트리거나, 적의 위치 또는 플레이어 진행 기반의 알고리즘을 사용합니다.

원문

18. 프리팹과 프리팹의 링크는 되나; 인스턴스와 인스턴스 간의 링크는 안된다. scene 에 프리팹을 끌어놓을 때 프리팹의 연결이 유지 됩니다; 인스턴스에는 링크가 없습니다. 프리팹을 연결할 때마다 scene 의 설정을 줄여 주는게 가능해지며, scene 을 변경할 경우도 줄여줄 수 있습니다.

원문

19. 가능하다면, 인스턴스간의 연결 설정은 자동으로 하라. 만약 당신이 인스턴스간의 링크를 필요로 한다면, 프로그래밍적으로 링크를 설정 합니다. 예를 들어, Player 프리팹 자체를GameManager 을 시작함과 동시에 등록 할 수 있으며, 또는 GameManager 가 시작 할때 Player 프리팹 인스턴스를 찾을 수 있습니다.

만약 당신이 프리팹에 다른 스크립트를 추가 하길 원한다면 루트에 다른 메시를 넣어선 안됩니다. 당신이 메시로 부터 프리팹을 만들려고 한다면, 첫번째 메시의 부모는 비어있는 게임 오브젝트 이어야 하며, 그것은 루트 이어야 합니다. 스크립트를 루트에 넣게 되면, 메시 노드가 아니게 됩니다. 그 방법은 당신이 inspector 에서 설정한 모든 값을 잃어버릴일 없이 다른 메쉬와 메시를 대체하기 훨씬 쉬울 것 입니다.

하위 프리팹의 대안으로 연결된 프리팹을 사용합니다. Unity 는 하위 프리팹을 허용하지 않으며, 하위 프리팹 간의 관계가 명확하지 않기 때문에 팀에서 작업 할 때 기존의 타사 솔루션은 위험 할 수 있습니다.

원문

20. 분기 프리팹에 대해서 안전한 절차를 사용하도록 하라. 설명은 Player 프리팹 예제를 통해서 합니다.

프리팹을 바꾸는거에 대해 많은 문제에 대한 절차는:

  1. 복제된 Player 프리팹이 있습니다.
  2. 복제된 거에 대한 이름을 __Player_Backup 로 변경합니다.
  3. Player prefab 으로 생성한걸 바꿉니다.
  4. 작업이 진행 될 경우 __Player_Backup 를 지웁니다

복제후 Player_New 으로 이름을 바꺼선 안되며, 생성된걸 바꺼선 안됩니다!

일부는 상황이 더 복잡합니다. 예를 들어, 특정 변화는 두 사람을 포함 할 수 있으며, 두사람이 위의 과정을 따라하면서 작업을 완료하면 작업한 scene 을 망가질 수 있습니다. If it is quick enough, still follow the process above 그래도 여전히 필요로 하는경우, 위의 절차를 따르십시오. 바꾸는데 시간이 오래 걸릴경우, 다음의 절차를 따라야 할 수 있습니다:

  1. 사람 1:
    1. Player 프리팹을 복제 합니다.
    2. 이름을 __Player_WithNewFeature 나 __Player_ForPerson2 로 바꿉니다.
    3. 복제된 걸로 변경을 하고, 커밋을 하여 [사람 2] 에게 제공합니다.
  2. 사람 2:
    1. 새로운 프리팹으로 변경 생성 합니다.
    2. Player 프리팹을 복제하고, __Player_Backup 이라고 부릅니다. 
    3. __Player_WithNewFeature 인스턴스를 scene 으로 드래그 합니다.
    4. 오리지날 Player 프리팹을 인스턴스에 드래그 합니다.
    5. 작업이 진행 될 경우 __Player_Backup 와 __Player_WithNewFeature 를 지웁니다.

원문

Extensions and MonoBehaviourBase

21. 기본 mono behaviour 을 확장하고, 당신의 컴포넌트를 그것으로부터 모두 파생하라. 

이렇게 하면 몇가지 일반적인 기능을 구현 할 수 있으며, 이러한 유형의 호출에 안전하고 복잡한 호출이 가능해 집니다.(예로 무작위 호출)

원문

22. Invoke 를 위해 안전한 메서드를 정의 하며, StartCoroutine 과 Instantiate 가 있다.

Task delegate 를 정의하고, 문자열 이름에 의존하지 않는 방법을 정의 하는데 사용합니다.
예를 들면:

public void Invoke(Task task, float time)
{
   Invoke(task.Method.Name, time);
}

원문

23. 공유 인터페이스를 사용하여 컴포넌트를 함께 작동하도록 확장을 사용 합니다. 가끔 특정 인터페이스의 구현된 컴포넌트를 얻어오는데 편리하거나, 앞의 언급한 컴포넌트를 가지고 오브젝트를 찾는데 편합니다.

아래에 구현된 내용은 typeof 대신에 generic 버전의 함수들로 사용되고 있습니다. generic 버전은 인터페이스와 함께 작동하지 않지만, typeof 는 가능합니다. 아래의 방법은 generic 메소드를 이용하여 래핑합니다.

//Defined in the common base class for all mono behaviours
public I GetInterfaceComponent<I>() where I : class
{
   return GetComponent(typeof(I)) as I;
}
 
public static List<I> FindObjectsOfInterface<I>() where I : class
{
   MonoBehaviour[] monoBehaviours = FindObjectsOfType<MonoBehaviour>();
   List<I> list = new List<I>();
 
   foreach(MonoBehaviour behaviour in monoBehaviours)
   {
      I component = behaviour.GetComponent(typeof(I)) as I;
 
      if(component != null)
      {
         list.Add(component);
      }
   }
 
   return list;
}

원문

24. 구문보다 편리하게 사용하기 위해 확장을 사용합니다. 예를 들면:

public static class CSTransform 
{
   public static void SetX(this Transform transform, float x)
   {
      Vector3 newPosition = 
         new Vector3(x, transform.position.y, transform.position.z);
 
      transform.position = newPosition;
   }
   ...
}

원문

25. 방어적인 GetComponent 를 대안으로 사용 하라. Sometimes forcing component dependencies (through RequiredComponent) can be a pain. 때때로 강제적인 컴포넌트 의존(RequiredComponent 유발)은 고통이 될 수 있습니다. 예를들어, it makes it difficult to change components in the inspector 그것은 어려운 inspector 의 구성요소를 변경 할 수 있습니다(base type 이 같은 경우). As an alternative, the following extension of GameObject can be used when a component is required to print out an error message when it is not found. 대안으로, 확장된 GameObject 를 찾을때 컴포넌트가 발견되지 않은 경우 오류 메세지를 출력 하면 된다.

public static T GetSafeComponent<T>(this GameObject obj) where T : MonoBehaviour
{
   T component = obj.GetComponent<T>();
 
   if(component == null)
   {
      Debug.LogError("Expected to find component of type " 
         + typeof(T) + " but found none", obj);
   }
 
   return component;
}

원문

Idioms

26. 비슷한 일에 다른 해결책을 사용하지 마십시오. 대부분의 경우 일을 할때마다 하나 이상의 해결책이 있습니다. 이러한 경우, 프로젝트에 한가지 방법을 선택하고 진행 할 수 있습니다. 여기에 이유가 있습니다:

  • 몇가지 해결책이 함께 잘 작동하지 않습니다. 한가지 해결챌을 사용하면 다른 해결책에 적합하지 않으며 한 방향으로 디자인을 강요 합니다.
  • 몇가지 해결책을 사용하는게 어디로 가야 하는지 팀 멤버를 이해 시킵니다. 이것은 구조와 코드를 이해하기 쉽게 합니다. 실수를 하기 더 쉽도록 유도가 됩니다.

해결책 그룹들의 예시:

  • Coroutines vs. state machines.
  • 하위 프리팹들 vs. 연결된(링크) 프리팹들 vs. 전지 전능한 프리팹들.
  • 데이터 분리 전략.
  • 2D 게임에서 상태를 위해 스프라이트를 사용 하는 방법.
  • 프리팹 구조화.
  • Spawn 전략.
  • 개체를 찾을 수 있는 방법: 타입 vs. 이름 vs. 태그 vs. 레이어 vs. 레퍼런스(링크).
  • 그룹 개체들을 찾는 방법: 타입 vs. 이름 vs. 태그 vs. 레이어 vs. 레퍼런스(링크) 배열
  • 오브젝트의 그룹들 찾기 vs 자체 등록 (싱글톤 객체?)
  • 실행 순서 제어 (Unity 를 이용하여 실행 순서 제어 vs. yield 로직 vs. Awake / Start 와 Update / Late Update 의존 vs. 수동 메소드 vs. 모든 주문 아키텍쳐)
  • 개체 / 위치 / 타겟 의 선택과 인 게임의 마우스: 선택 관리자 vs 로컬 자체 관리
  • scene 변화와 데이터 간의 유지: PlayerPrefs 를 통해, 또는 새로운 scene 이 로드 될때 지워지지 않은 객체.
  • 애니메이션 결합 방법 (블렌딩, 더하거나 레이어링(계층관리)).

원문

Time

27. 쉽게 일시 중지 하기 위해 당신만의 Time class 를 유지 하라. Wrap Time.DeltaTime 와 Time.TimeSinceLevelLoad 은 계정 별 일시 중지와 시간 scale 이 가능합니다. 이것을 사용하는데는 훈련이 필요로 하지만, 많은 부분에 대해 쉽게 제작 가능하며, 특히 다른 Time 의 일을 실행 하기 편합니다. (예로 interface 애니메이션과 게임 애니메이션 등)

원문

Spawning Objects

28. 게임이 실행 될 때 생성되는 개체가 계층 구조를 더럽히게 하지 말라. Set their parents to a scene object to make it easier to find stuff when the game is running. 
게임이 실행 중 일때 개체를 쉽게 찾을 수 있도록 scene 개체에 부모를 설정 합니다. 비어있는 게임 오브젝트를 사용하거나 behaviour 가 없는 싱글톤을 이용하여 만들면 코드에 접근하기 쉽습니다. 이 오브젝트를  DynamicObjects 라고 부릅니다.

원문

Class Design

29. 편의를 위해 싱글톤 을 사용하라. 다음 클래스는 자동으로 싱글톤 을 상속하는 클래스를 만들 것 입니다:

public class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
   protected static T instance;
 
   /**
      Returns the instance of this singleton.
   */
   public static T Instance
   {
      get
      {
         if(instance == null)
         {
            instance = (T) FindObjectOfType(typeof(T));
 
            if (instance == null)
            {
               Debug.LogError("An instance of " + typeof(T) + 
                  " is needed in the scene, but there is none.");
            }
         }
 
         return instance;
      }
   }
}

싱글톤은 관리자에 유용하며, ParticleManager 또는 AudioManager 또는  GUIManager 등이 있습니다.

  • 고유한 프리팹의 인스턴스를 위한 싱글톤은 사용하는걸 피하는고 관리하지 않는게 좋습니다(Player 같은). 이 원칙을 준수하지 않으면 상속 계층 구조를 복잡하게 하며, 그리고 특정 유형의 변경을 힘들게 합니다. 오히려 GameManager 에서 참조를 유지하는게 좋습니다.(또는 다른 전지 전능한 클래스 ;-))
  • 종종 클래스 외부에서 사용되는 public 변수 와 메소드 에 대한 static 속성과 메서드를 사용합니다. GameManager.Instance.player 대신에  GameManager.Player 으로 작성이 가능합니다.

원문

30. component 들을 들어, inspector 에 변화를 주지 말아야 할 변수는 공개 하지 않습니다. 그렇지 않으면 그것은 무엇을 하는지 알수 없게 되여 디자이너가 변경을 해버리게 됩니다. 이런 경우 두줄 이나 네줄의 언더스코어를 접두로 변수 이름에 붙이면 수정을 꺼리게 될 것이다.
(역자 : 이런 경우 [HideInspector] 를 변수 상위에 붙이면 아예 노출이 일어나지 않습니다)

public float __aVariable;

원문

31. 게임 로직에서 인터페이스를 분리하여 제공합니다. 이것은 기본적으로 MVC 패턴 입니다.

모든 입력 컨트롤러는 호출되여 알려 해당 컴포넌트에 명령을 제공해야 합니다. 컨트롤러 로직을 예로, 컨트롤러는 플레이어의 상태에 따라 제공할 명령을 결정 할 수 있습니다. 그러나 이것은 안좋습니다 (예로 컨트롤러를 더 추가하는 경우 중복된 로직으로 불릴 가능성이 있습니다). 대신에, 플레이어 객체는 앞으로 이동을 할 경우에 통지 해야만 하며,  현재 상태(예를 들어 느려졌거나 아니면 기절)에 따라 속도를 설정하고 Player 의 방향을 업데이트 합니다. 컨트롤러는 자신의 상태에 관한 일을 해야 합니다(컨트롤러는 플레이어가 상태를 바꾸려고 할때 상태가 바뀐 상태인지 알수가 없습니다; 따라서, 컨트롤러는 전혀 플레이어의 상태를 알수 없습니다). 또 다른 예는 무기의 변화 입니다. 할 수 있는 옳은 방법은 GUI 가 플레이어의 SwitchWeapon 을 호출 하는 방법입니다. GUI 는 transform 과 부모와 모든 요소에 대해서 조작해선 안됩니다.

모든 인터페이스 컴포넌트는 데이터를 유지해야하고 자신의 상태에 관한 처리를 합니다. 예로, 맵을 표시하거나, GUI 는 플레이어의 움직임에 따라 표시 할수 있도록 계산을 합니다. 그러나, 이것이 게임 상태 데이터 이면, GUI 에 속해서는 안됩니다. GUI 는 단지 게임 상태 데이터를 표시해야 하며, 데이터는 다른곳에 유지해야 합니다. map 데이터는 다른곳에서 유지해야 합니다(예를 들어, GameManager 에서).

게임플레이 오브젝트는 GUI 에 대해서 아는게 거의 없습니다. 한가지 예외는 일시 정지 행동으로, Time.timeScale 을 통해 전체적으로 제어 합니다(물론 이는 좋은 생각은 아닙니다.. 보기에는). 게임플레이 오브젝트는 게임이 멈춘 상태일 때 알아야 합니다. 하지만 그게 전부 입니다. 따라서 게임 플레이 오브젝트로 부터 GUI 컴포넌트를 연결할 필요는 없습니다.

일반적으로, 당신이 GUI 클래스들을 모두 지울 경우에도, 게임은 여전히 컴파일 되야 합니다.

당신은 또한 GUI 와 input 을 재 구현시 새로운 게임 로직을 작성할 필요가 없어야 합니다.

원문

32. 별도의 상태와 Bookkeeping. Bookkeeping 변수는 빠르게 또는 편리하게 사용하기 위함이며, 그리고 현재 상태로부터 복구하는걸 가능하게 해준다. 이렇게 분리하면, 당신은 더 쉽게 적용 가능하다.

  • 게임 상태 저장, 그리고
  • 게임 상태 디버그

한가지 방법은 각각의 게임 로직 클래스를 위해 SaveData 클래스를 정의 하는 것이다.

[Serializable]
PlayerSaveData
{
   public float health; //public for serialisation, not exposed in inspector
} 
 
Player
{
   //... bookkeeping variables
 
   //Don’t expose state in inspector. State is not tweakable.
   private PlayerSaveData playerSaveData; 
}

원문

33. 별도의 특성화 구성.

동일한 메시들로 두개의 적을 고려 하는데, 벨런스 값이 다르다.(예를 들어 다른 힘과 다른 스피드를 가지고 있는경우). 별도의 데이터에 대해 여러가지 방법이 있습니다. 이중에 하나는 내가 원하는 것일거라 생각하며, 오브젝트가 생성될 때나, 게임이 저장될 때 입니다.

(Tweakable 들은 상태 데이터가 아니나 구성 데이터로, 그래서 저장할 필요가 없습니다. 개체가 로드 되거나 생성되는경우, tweakable 들은 별도로 자동으로 로드 됩니다.)

  • 각각의 게임 클래스에 템플릿 클래스를 정의합니다. 예로, 적인 경우 우리는 또한 EnemyTemplate 라고 정의 합니다. 모든 차별화된 tweakable 들은 EnemyTemplate 에 저장합니다.
  • 게임 로직 클래스 에는, 변수나 템플릿 타입을 정의 합니다.
  • 적 프리팹을 만들고, 두개의 템플릿 프리팹 WeakEnemyTemplate, andStrongEnemyTemplate 을 만듭니다.
  • 로딩하거나 오브젝트를 생성하면, 정식 템플릿에 템플릿 변수를 설정 합니다.

이 방법은 매우 정교한 방법이 될 수 있습니다. (그리고 때로는 불필요하게 복잡하므로 주의!)

예를 들어, generic 다형성을 사용하기 위해, 우리는 아마 이런식으로 정의 하는게 좋을겁니다:

public class BaseTemplate
{
   ...
}
 
public class ActorTemplate : BaseTemplate
{
   ...
}
 
public class Entity<EntityTemplateType> where EntityTemplateType : BaseTemplate
{
   EntityTemplateType template;
   ...
}
 
public class Actor : Entity <ActorTemplate>
{
   ...
}

원문

34. 표시 텍스트 이외에 다른 용도로 문자열을 사용하지 마시오. 특히, 개체 나 프리팹의 식별을 위해서 문자열을 사용하지 않습니다. 한가지 어쩔수 없는 예외는 애니메이션 으로, 일반적으로 자신의 문자열 이름으로 접근 할수 있습니다.

원문

35. Avoid using public index-coupled arrays 공개된 인덱스 결합 배열을 사용하지 마시오. 예로 무기 배열, 총알 배열, 파티클 배열 을 정의 하지 않는 것으로, 이런 경우에 대해서 좋은 방법은 아래와 같습니다:
(역자 : 배열의 인덱스를 직접적으로 사용하는걸 줄이라는 의미 인거 같습니다)

public void SelectWeapon(int index)
{ 
   currentWeaponIndex = index;
   Player.SwitchWeapon(weapons[currentWeapon]);
}
 
public void Shoot()
{
   Fire(bullets[currentWeapon]);
   FireParticles(particles[currentWeapon]);   
}

이런 코드를 많이 사용 하지 않는 문제는, inspector 에 설정 할 때 실수를 할 가능성이 있기 때문 입니다.

오히려, 세 변수를 캡슐화 하는 클래스를 정의하고 그 배열을 확인 하십시오.

[Serializable]
public class Weapon
{
   public GameObject prefab;
   public ParticleSystem particles;
   public Bullet bullet;
}

이 코드는 보기에 단정해 보이나, 매우 중요하며, inspector 에 데이터를 셋팅할 때 실수하기 어렵습니다.

원문

36. 시퀀스 이외의 다른 구조에 대한 배열을 사용하지 마시오. 예로, 플레이어가 세개의 공격 타입을 가지고 있다고 칩시다. 각각 현재 무기를 사용하지만 서로 다른 포탄과 다른 동작을 생성합니다.

당신은 아마 배열을 사용해 세개의 총알을 발사 하려하며, 이러한 로직을 사용할 것입니다:

public void FireAttack()
{
   /// behaviour
   Fire(bullets[0]);
}
 
public void IceAttack()
{
   /// behaviour
   Fire(bullets[1]);
}
 
public void WindAttack()
{
   /// behaviour
   Fire(bullets[2]);
}

Enums 을 사용하면 좀 더 나은 코드가 될 수 있습니다...

public void WindAttack()
{
   /// behaviour
   Fire(bullets[WeaponType.Wind]);
}

그러나 inspector 에서는 안됩니다.

그것은 별도의 변수를 사용하는 것이 좋기 때문에 어떤 콘텐츠를 넣어도 이름으로 도움말이 될 수 있습니다. 타입이 단정 지어질때 클래스를 만듭니다.
[Serializable]

public class Bullets
{
   public Bullet FireBullet;
   public Bullet IceBullet;
   public Bullet WindBullet;
}

Fire 를 설정하면 Ice 와 Wind 데이터는 없다고 가정합니다.

원문

37. serializable 클래스의 그룹 데이터는 가까운거 끼리 모아 inspector 로 만들어야 한다 . 어떤 엔티티는 수십개의 조절할게 있을수 있습니다.  이 경우 inspector 에 연결될 변수를 찾는게 악몽이 될 수 있습니다. 더 쉽게 만들기 위해, 다음의 단계를 따르십시오: 

  • 변수의 그룹에 대한 별도의 클래스를 정의 합니다. 
    그것들을 public 및 serializable 합니다.
  • 기본 클래스에서, 위와 같이 정의된 각각의 유형의 public 변수를 정의 합니다.
  • 변수를 Awake 나 Start 에서 초기화 하면 안되며; 그것들은 serializable 이기 때문에, Unity 에서 잘 처리 해줄 것입니다.
  • 당신은 정의된 변수가 연결되기 전에 초기화를 지정하는게 가능하다 

inspector 의 접을 수 있는 공간의 그룹 변수들은, 관리를 쉽게 합니다.
 

[Serializable]
public class MovementProperties //Not a MonoBehaviour!
{
   public float movementSpeed;
   public float turnSpeed = 1; //default provided
}
 
public class HealthProperties //Not a MonoBehaviour!
{
   public float maxHealth;
   public float regenerationRate;
}
 
public class Player : MonoBehaviour
{
   public MovementProperties movementProeprties;
   public HealthPorperties healthProeprties;
}

원문

Text

38. 스토리 텍스트가 많은 경우, 파일에 넣도록 합니다. inspector 의 에디팅 할수 있는 영역으로 두지 마십시오. 이것은 Unity 에디터를 열지 않고도 변경을 쉽게 해줄 것이며, 특히 scene 을 저장하지 않고도 가능할 것입니다.

원문

39. 당신이 로컬라이징을 할 계획이 있다면, 하나의 지역에 모든 문자열을 분리합니다. 
이 작업을 수행하는 방법에는 여러가지가 있습니다. 한가지 방법은 예를 들어, 기본값을 영어로 설정하고, 각 문자열에 대한 공개 문자열 필드에 텍스트 클래스를 정의 하는 것입니다. 다른 언어는 하위 클래스를 두고 언어에 맞추어 다시 초기화 하는 것입니다.

더 정교한 기법은 (텍스트의 길이가 길고 / 길거나 언어의 갯수가 많은 경우 적절합니다)sheet 로부터 읽어오고 선택된 언어로부터 기본이 되는 문자열을 선택해서 로직에 제공 하는 것입니다.

원문

Testing and Debugging

40. 물리, 애니메이션, 그리고 AI 를 디버깅하기 위해 그래픽 logger를 구현 합니다. 이건 상당히 빠르게 디버깅 할 수 있게 합니다. 여기에 자세한 정보가 있습니다 here.

원문

41. HTML logger를 정의 합니다.  몇가지 경우에 대해서, logging 은 매우 유용 합니다. 
구문 분석(컬러 코드, 멀티 뷰, 스크린샷 기록)을 하게 되면 로그를 디버깅 하는게 훨씬 쾌적 할 수 있습니다. 여기에 자세한 정보가 있습니다 here.

원문

42. 당신의 FPS counter 를 구현합니다. 예. Unity 의 FBS counter 가 정말 제대로 측정할지도 모르나, 그것은 프레임 레이트가 아닙니다. 직관과 육안 검사와 일치 할 수 있도록 자신의 것을 구현 합니다.

원문

43. Implement shortcuts for taking screen shots 스크린샷을 이용해 바로가기를 구현 합니다.  많은 버그는 비쥬얼이며, 그리고 당신은 사진을 찍어두면 보고가 좀 더 쉬워집니다. 이상적인 시스템은 스크린샷을 덮어씌우지 않도록 PlayerPrefs 의 카운터를 유지 해야 합니다. 스크린샷은 실수로 사람들이 저장소에 커밋하는걸 방지하기 위해 프로젝트 폴더 외부에 저장해야 합니다.

원문

44. 플레이어의 월드 위치를 출력하기 위한 바로가기를 구현 합니다. 이것은 월드의 특정 장소에서 발생하는 버그의 위치를 리포트를 하기 쉬워질 것이며, 이는 번갈아 가면서도 쉽게 디버깅 할 수 있습니다.

원문

45. 테스트를 쉽게 만들기 위한 디버그 옵션을 구현합니다. 몇가지 예를 들면:

  • 모든 아이템 언락
  • 적 제거
  • GUI 끄기
  • 플레이어 무적
  • 모든 게임 플레이 불가.

원문

46. 충분히 작은 팀의 경우, 디버그 옵션을 사용하여 각 팀의 구성원을 위한 prefab 을 만듭니다. 파일에 사용자 ID 를 넣고: 게임이 실행 될 때 읽어집니다. 이 이유는:

  • 팀 구성원은 사고로 자신의 디버그 옵션을 커밋 하고 모두에게 영향을 미치기 않기 위함입니다.
  • 디버그 옵션을 바꾸는 것은 scene 을 바꾸는게 아니기 때문입니다.

원문

47. 모든 게임 플레이 요소와 scene 을 유지 합니다. 예로, 모든 적이 있는 scene, 당신이 상호 작용 할수 있는 모든 개체, 그외 등등. 너무 오래 게임을 하지 않고 기능을 테스트 할 수 있도록 합니다.

원문

48. 디버그 바로 가기 키를 위한 상수를 정의하고, 한 곳에서 보관 합니다. 디버그 키는 일반적으로 (또는 편리한) 게임 입력이 처리 되는 위치에서 같이 처리 되지는 않습니다. 바로 가기 키의 충돌을 방지 하기 위해 중앙 위치에 상수를 정의 합니다. 대안으로 디버그 함수인지 아닌지 상관없이 한 곳에 모든 키를 처리 하는 겁니다. (단점은 이 클래스는 이 개체에 대해서 참조를 추가로 해야 할 수도 있습니다)

원문

Documentation

49. 설치를 문서화 합니다. 대부분의 코드는 문서에 있어야 하며, 하지만 이러한 것은 코드 외부에서 문서화 해야합니다. 디자이너가 설정하기 위한 코드를 선별하여 만드는것은 시간 낭비 입니다. 문서 설정이 효율이 극대화 됩니다 (만약 문서가 최신이라면).

다음 사항을 문서화 합니다:

  • 레이어 사용 (충돌, 컬링, raycasting – essentially, 어떤 항목에 어떤걸 해야)
  • 태그 사용.
  • 레이어를 위한 GUI 깊이 (무엇을 통해서 표시해야)
  • scene 설치
  • Idiom 설정
  • 프리팹 구조
  • 애니메이션 레이어

원문

Naming Standard and Folder Structure

50. 문서화 규칙 및 폴더 구조를 따르시오. 일관성 규칙 및 폴더 구조는 쉽게 찾고자 하는걸 찾을 수 있으며, 일이 무엇인지 파악 할 수 있습니다.

당신은 아마도 자신의 규칙 및 폴더 구조를 생성 할 수 있습니다. 다음의 예는 한가지 입니다.

원문

Naming General Principles

  1. 무언가를 호출 합니다. bird 는 Bird 를 호출 합니다. 
  2. 이름을 선택 할 때는 확연하고 기억될 수 있는 이름으로 선택합니다. 만약 당신이 마야 게임을 만든다고 해서, 레벨 이름을 QuetzalcoatisReturn 로 해서는 안됩니다.
  3. 일관성을 유지 하십시오. 이름을 선택할때, 기준에 충실해야 합니다.
  4. Use Pascal case, like this: ComplicatedVerySpecificObject. Do not use spaces, underscores, or hyphens, with one exception (see Naming Different Aspects of the Same Thing).
    이와같이 파스칼 케이스를 사용합니다: ComplicatedVerySpecificObject. 공간( ), 언더바(_), 또는 하이푼(-), 한가지 예외와 함께 (같은 일에 다른 이름을 보게 될 경우)
  5. 버전 번호를 사용하지 말고, 또는 단어로 진행 상태를 표시 하지 마십시오 (WIPfinal).
  6. Do not use abbreviations: DVamp@W should be DarkVampire@Walk.
    약어를 사용하지 마십시오: DVamp@W 는 DarkVampire@Walk .으로 표기 합니다
  7. 디자인 문서의 용어를 사용합니다: 사망 을 문서상 호출 하려면 Die 애니메이션을 부릅니다. DarkVampire@Die, 를 부르며 DarkVampire@Death 는 안됩니다.
  8. 구체적인 설명은 왼쪽에 표기 합니다: DarkVampire 는 좋은 방법이며 VampireDark 는 안좋은 방법입니다. PauseButton는 좋은 방법이며 ButtonPaused는 안좋은 방법입니다. 이것을 예로 들면, 모든 버튼이 단어 버튼으로 시작하면 inspector 에서 일시 정지 버튼을 찾기 쉬워집니다. [많은 사람들이 다른 방법을 더 선호하며, 때문에 시각적으로 보다 더 확실히 그룹화를 하여 생성합니다. 이름이 있지만 그룹화를 위한게 아니며, 폴더를 위한것 입니다. 이름이 안정적으로 빠르게 자리 잡고 할 수 있도록 동일한 유형의 객체를 구분하는 것 입니다.]
  9. 일부 이름은 순서를 형성합니다. 이름에 숫자를 사용하며, 예로 PathNode0,PathNode1 가 있습니다. 항상 시작은 1이 아닌 0으로 시작합니다.
  10. 순서를 필요로 하지 않는 일에 번호를 사용하지 마십시오. 예로 Bird0Bird1,Bird2 는 FlamingoEagleSwallow 라고 표기합니다.
  11. 임시 객체는 이중으로 접두사에 언더바를 넣습니다 __Player_Backup.

원문

Naming Different Aspects of the Same Thing

언더바와 핵심 이름을 사용하여, 해당 상태에 "세부" 내용 설명합니다. 예로 들면:

  • GUI 버튼 상태는 EnterButton_Active, EnterButton_Inactive
  • 텍스쳐는 DarkVampire_Diffuse, DarkVampire_Normalmap
  • 스카이 박스는 JungleSky_Top, JungleSky_North
  • LOD 그룹은 DarkVampire_LOD0, DarkVampire_LOD1

단지 다른 유형의 항목 구분이 규칙을 사용하면 안되며, 예로  Rock_Small, Rock_Large 를 SmallRock, LargeRock 으로 사용 하는 경우 입니다.

원문

Structure

당신의 scene 의 구성, 프로젝트 폴더, 그리고 스크립트 폴더는 유사한 패턴을 가져야 합니다.

원문

Folder Structure

Materials
GUI
Effects
Meshes
   Actors
      DarkVampire
      LightVampire
      ...
   Structures
      Buildings
      ...
   Props
      Plants
      ...
   ...
Plugins
Prefabs
   Actors
   Items
   ...
Resources
   Actors
   Items
   ...
Scenes
   GUI
   Levels
   TestScenes
Scripts
Textures
GUI
Effects
...

Scene Structure

Cameras
Dynamic Objects
Gameplay
   Actors
   Items
   ...
GUI
   HUD
   PauseMenu
   ...
Management
Lights
World
   Ground
   Props
   Structure
   ...

Scripts Folder Structure

ThirdParty
   ...
MyGenericScripts
   Debug
   Extensions
   Framework
   Graphics
   IO
   Math
   ...
MyGameScripts
   Debug
   Gameplay
      Actors
      Items
      ...
   Framework
   Graphics
   GUI
   ...

How to Re-implement Inspector Drawing

1. 당신의 모든 에디터를 위한 기본 클래스를 정의

BaseEditor<T> : Editor 
where T : MonoBehaviour
{
   override public void OnInspectorGUI()
   {
      T data = (T) target;
 
      GUIContent label = new GUIContent();
      label.text = "Properties"; //
 
      DrawDefaultInspectors(label, data);
 
      if(GUI.changed)
      {         
         EditorUtility.SetDirty(target);
      }
   }
}

2. reflection 과 recursion 를 사용하여 draw 컴포넌트에 reflection 을 사용

public static void DrawDefaultInspectors<T>(GUIContent label, T target)
   where T : new()
{
   EditorGUILayout.Separator();
   Type type = typeof(T);      
   FieldInfo[] fields = type.GetFields();
   EditorGUI.indentLevel++;
 
   foreach(FieldInfo field in fields)
   {
      if(field.IsPublic)
      {
         if(field.FieldType == typeof(int))
         {
            field.SetValue(target, EditorGUILayout.IntField(
            MakeLabel(field), (int) field.GetValue(target)));
         }   
         else if(field.FieldType == typeof(float))
         {
            field.SetValue(target, EditorGUILayout.FloatField(
            MakeLabel(field), (float) field.GetValue(target)));
         }
 
         ///etc. for other primitive types
 
         else if(field.FieldType.IsClass)
         {
            Type[] parmTypes = new Type[]{ field.FieldType};
 
            string methodName = "DrawDefaultInspectors";
 
            MethodInfo drawMethod = 
               typeof(CSEditorGUILayout).GetMethod(methodName);
 
            if(drawMethod == null)
            {
               Debug.LogError("No method found: " + methodName);
            }
 
            bool foldOut = true;
 
            drawMethod.MakeGenericMethod(parmTypes).Invoke(null, 
               new object[]
               {
                  MakeLabel(field),
                  field.GetValue(target)
               });
         }      
         else
         {
            Debug.LogError(
               "DrawDefaultInspectors does not support fields of type " +
               field.FieldType);
         }
      }         
   }
 
   EditorGUI.indentLevel--;
}

위 method 는다음과 같은 헬퍼를 사용한다:

private static GUIContent MakeLabel(FieldInfo field)
{
   GUIContent guiContent = new GUIContent();      
   guiContent.text = field.Name.SplitCamelCase();      
   object[] descriptions = 
      field.GetCustomAttributes(typeof(DescriptionAttribute), true);
 
   if(descriptions.Length > 0)
   {
      //just use the first one.
      guiContent.tooltip = 
         (descriptions[0] as DescriptionAttribute).Description;
   }
 
   return guiContent;
}

이 inspector 에 툴팁을 생성하기 위해 클래스 코드에 주석을 사용합니다.

3. Define new Custom Editors

불행하게도, 당신은 여전히 각각의 MonoBehaviour 를 위한 클래스를 정의 해야 합니다. 다행히도, 이러한 정의는 비어 있을것이며; 모든 실제 작업은 기본 클래스에 의해 이루어 집니다.

[CustomEditor(typeof(MyClass))]
public class MyClassEditor : BaseEditor<MyClass>
{}

이론적으로 이 단계는 자동일 수 있지만, 난 아직 시도 해보지 않았습니다.


[출처] Unity3d 50가지 팁|작성자 다크엔젤

반응형
Posted by blueasa
, |

Unity3D SVN 연동방법

협업/SVN / 2012. 12. 25. 12:53


- 유니티 설정 바꾸기


1. 자신의 유니티 프로젝트를 엽니다.


2. 상단 메뉴에 Edit - Project Settings - Editor 를 누릅니다.




3. 그러면 오른쪽 Inspector창에 Editor Settings가 뜨는데

    Version Control 항목이 있습니다. 거기서 Disable을 Meta Files로 바꿔줍니다.


    스샷에서 빼먹은 부분이 있는데 Inspector창 맨 아래에 Asset Srialization Mode를 Force 

    Text로 바꿔주시기 바랍니다.




4. 프로젝트를 저장 하시고, Unity를 끕니다.




여기까지 따라 하셨다면 이제 SVN설정을 합시다.


SVN 체크아웃된 경로 안에 프로젝트 폴더가 복사되어 있다고 가정하고 쓰겠습니다.


중요한것은 프로젝트 경로명에 한글이 들어가서는 절대로 안됩니다.


- SVN 설정하기


1. 프로젝트 폴더에서 무시목록을 추가합니다.


obj

Temp

*.suo

*.user

*.pidb

*.userprefs


2. 프로젝트 폴더 안에 Library 폴더에서 무시목록을 추가합니다.


cache

metadata

previews

ScriptAssemblies

assetDatabase3

AssetImportState

assetservercachev3

AssetServerCacheV3

AssetVersioning.db

AudioManager.asset

BuildPlayer.prefs

BuildSettings.asset

DynamicsManager.asset

EditorSettings.asset

EditorUserBuildSettings.asset

expandedItems

FailedAssetImports.txt

guidmapper

InspectorExpandedItems.asset

MonoManager.asset

NetworkManager.asset

ScriptMapper

unity default resources

unity editor resources


2. 프로젝트 폴더 안에 Library 폴더를 무시목록에 추가합니다.

(위에 추가하는거나 Library폴더 전체 무시나 같더군요)


3. 커밋합니다.




- SmartSVN에서 설정하기 (회사에서 SmartSVN을 사용하기 때문에 SmartSVN에 대한 설명도 적겠습니다.)


1. SmartSVN을 켭니다.


2. 해당 프로젝트를 SVN 경로에 복사합니다.



3. Assets 폴더를 오른쪽 클릭후 Add 누르고 OK를 누릅니다.



4. ProjectSettings 폴더를 오른쪽 클릭후 Add 누르고 OK를 누릅니다.



5. 해당 프로젝트에 오른쪽 클릭후 Properties - Ignore Patterns를 누릅니다.



6. 위에 무시목록을 복사해서 붙여넣은 후 OK를 누릅니다. (Depth는 기본상태로 둡니다)



7. 해당 프로젝트에 Library 폴더에 오른쪽 클릭 후 Add 를 누릅니다. (OK버튼 바로 누르지 않도록 주의)



8. Add 팝업창에서 Depth를 Only this directory로 변경 후 OK를 누릅니다.



9. 해당 프로젝트에 Library 폴더에 오른쪽 클릭 후 Properties - Ignore Patterns를 누릅니다.



10. 위의 무시목록을 복사해서 붙여넣은 후 Depth를 Immediate children (files and directories)를 선택한 뒤 OK를 누릅니다.



11. Library 폴더에 전체 선택후 Add를 누릅니다.




그냥 Library 폴더를 무시목록 추가하고 OK 누르시면 됩니다.


12. 커밋합니다.


출처 : http://sekainonaka.tistory.com/170

반응형

'협업 > SVN' 카테고리의 다른 글

Unity SVN 연동  (0) 2014.04.11
Unity3D SVN 연동 방법  (0) 2014.01.03
Posted by blueasa
, |