무르르릉

<svn Ignore 목록>

*.o *.lo *.la *.al .libs *.so *.so.[0-9]* *.a *.pyc *.pyo __pycache__ *.rej *~ #*# .#* .*.swp .DS_Store [Tt]humbs.db obj Temp *.suo *.user *.pidb *.userprefs *.csproj *.pidb *.sln *.csproj *.unityproj Library Temp Logs UserSettings .vsconfig .obj .vs

바이너리파일 만지기X -> 따로 파서 진행 ex. 프리팹, 씬

작업하기 전에 무조건 svn Update 진행

commit 후 알리기 -> 신중하게 해야됨 의미 없는 commit 줄이기

유니티 프로젝트에서 show in explorer 눌러서 커밋작업 해야함

인스펙터에서 작업한 것 저장 위해 save project 해야됨

https://www.acmicpc.net/problem/2468

문제

재난방재청에서는 많은 비가 내리는 장마철에 대비해서 다음과 같은 일을 계획하고 있다. 먼저 어떤 지역의 높이 정보를 파악한다. 그 다음에 그 지역에 많은 비가 내렸을 때 물에 잠기지 않는 안전한 영역이 최대로 몇 개가 만들어 지는 지를 조사하려고 한다. 이때, 문제를 간단하게 하기 위하여, 장마철에 내리는 비의 양에 따라 일정한 높이 이하의 모든 지점은 물에 잠긴다고 가정한다.

어떤 지역의 높이 정보는 행과 열의 크기가 각각 N인 2차원 배열 형태로 주어지며 배열의 각 원소는 해당 지점의 높이를 표시하는 자연수이다. 예를 들어, 다음은 N=5인 지역의 높이 정보이다.

이제 위와 같은 지역에 많은 비가 내려서 높이가 4 이하인 모든 지점이 물에 잠겼다고 하자. 이 경우에 물에 잠기는 지점을 회색으로 표시하면 다음과 같다. 

물에 잠기지 않는 안전한 영역이라 함은 물에 잠기지 않는 지점들이 위, 아래, 오른쪽 혹은 왼쪽으로 인접해 있으며 그 크기가 최대인 영역을 말한다. 위의 경우에서 물에 잠기지 않는 안전한 영역은 5개가 된다(꼭짓점으로만 붙어 있는 두 지점은 인접하지 않는다고 취급한다).

또한 위와 같은 지역에서 높이가 6이하인 지점을 모두 잠기게 만드는 많은 비가 내리면 물에 잠기지 않는 안전한 영역은 아래 그림에서와 같이 네 개가 됨을 확인할 수 있다. 

 

 

이와 같이 장마철에 내리는 비의 양에 따라서 물에 잠기지 않는 안전한 영역의 개수는 다르게 된다. 위의 예와 같은 지역에서 내리는 비의 양에 따른 모든 경우를 다 조사해 보면 물에 잠기지 않는 안전한 영역의 개수 중에서 최대인 경우는 5임을 알 수 있다. 

어떤 지역의 높이 정보가 주어졌을 때, 장마철에 물에 잠기지 않는 안전한 영역의 최대 개수를 계산하는 프로그램을 작성하시오. 

5
6 8 2 6 2
3 2 3 4 6
6 7 3 3 2
7 2 5 3 6
8 9 5 2 7

5

7
9 9 9 9 9 9 9
9 2 1 2 1 2 9
9 1 8 7 8 1 9
9 2 7 9 7 2 9
9 1 8 7 8 1 9
9 2 1 2 1 2 9
9 9 9 9 9 9 9

6

풀이

• (N,N) 크기의 2차원 배열 생성 후 높이 입력
• BFS를 사용하여 값 탐색. 좌표값 x, y와 해당 위치값(높이)을 매개변수로 전달 -> Bfs(x, y, N)
• 값이 높이(N)보다 높을 경우 BFS 실행하고 영역 개수 증가
• 배열에 입력된 숫자들의 최소, 최대값만큼 반복문을 돌리면서 모든 높이에 대한 영역의 수 저장
• min(map(min, board))/max(map(max, board)): map(func, iterable)은 해당 요소(iterable)를 특정 함수(func)로 변환해주는 함수이다. map 함수의 반환값은 map객체이기 때문에, list 또는 tuple로 변환하여 값을 얻어와야 한다. 아래 코드는 반환된 map 객체에서의 최소(min()), 최대(max())값을 추출한다.

# 예제 1 사용하여 board(2차원 배열)에 값 넣었을 경우
minHeight = min(map(min, board))	# 2
maxHeight = max(map(max, board))	# 9

• range(x, y): x부터 y-1 범위
• Bfs가 실행되면 방문 처리를 하기 때문에, 탐색 후 방문 배열 초기화 + 영역의 수 초기화

# 2부터 9까지 반복하고 싶을 경우
minHeight = 2
maxHeight = 9

for h in range(minHeight, maxHeight)	# h = [2, 3, 4, 5, 6, 7, 8] -> X
for h in range(minHeight, maxHeight + 1)	# h = [2, 3, 4, 5, 6, 7, 8, 9] -> O

• 각 높이에 대한 영역의 수를 배열에 담고 max() 사용하여 최대값 출력

전체 코드

from collections import deque;

# 상하좌우 방향
dx = [0, 0, 1, -1]
dy = [1, -1, 0, 0]

# 물에 잠기지 않은 영역의 수
cnt = 0

# 반복문을 돌면서 최대 영역을 저장하는 배열 -> max()사용하여 최대 영역 수 출력
arrArea = []

# Bfs 함수가 실행되면서 좌표를 데크에 저장
# 해당 좌표 방문 처리(True)
def Bfs(x, y, h):
    q = deque()
    q.append((x, y))
    visited[x][y] = True

    # 가장 앞부분부터 꺼내어 상하좌우 탐색
    while q:
        x, y = q.popleft()
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]

            # 값이 맵 밖으로 벗어나면 실행 X
            if nx < 0 or nx >= N or ny < 0 or ny >= N:
                continue
            # 주변에 위치한 값이 매개변수로 받아온 높이보다 크거나 같고,
            # 방문하지 않았다면 큐에 저장하고 방문 처리 작업 진행
            if board[nx][ny] >= h and not visited[nx][ny]:
                q.append((nx, ny))
                visited[nx][ny] = True

if __name__ == "__main__":
    N = int(input())
    board = [list(map(int, input().split())) for _ in range(N)]
    visited = [[False] * N for _ in range(N)]

    # 입력한 2차원 배열의 최소, 최대값
    minHeight = min(map(min, board))
    maxHeight = max(map(max, board))

    # 높이의 값이 최소부터 최대일 때까지 반복문 실행 
    for h in range(minHeight, maxHeight + 1):
        # 방문 배열, 영역의 수 초기화 -> 방문 처리가 되어있으면 각 높이에 따른 Bfs 실행 불가
        visited = [[False] * N for _ in range(N)]
        cnt = 0

        # 배열의 크기만큼 반복문 돌면서 물에 잠기지 않고, 방문하지 않았다면 Bfs 실행하고 영역의 수 증가
        for i in range(N):
            for j in range(N):
                if board[i][j] >= h and not visited[i][j]:
                    Bfs(i, j, h)
                    visited[i][j] = True
                    cnt += 1
        arrArea.append(cnt)

    # 배열에 담긴 영역의 수 중 최대값 출력
    print(max(arrArea))

https://www.acmicpc.net/problem/2583

문제

눈금의 간격이 1인 M×N(M,N≤100)크기의 모눈종이가 있다. 이 모눈종이 위에 눈금에 맞추어 K개의 직사각형을 그릴 때, 이들 K개의 직사각형의 내부를 제외한 나머지 부분이 몇 개의 분리된 영역으로 나누어진다.

예를 들어 M=5, N=7 인 모눈종이 위에 <그림 1>과 같이 직사각형 3개를 그렸다면, 그 나머지 영역은 <그림 2>와 같이 3개의 분리된 영역으로 나누어지게 된다.

<그림 2>와 같이 분리된 세 영역의 넓이는 각각 1, 7, 13이 된다.

M, N과 K 그리고 K개의 직사각형의 좌표가 주어질 때, K개의 직사각형 내부를 제외한 나머지 부분이 몇 개의 분리된 영역으로 나누어지는지, 그리고 분리된 각 영역의 넓이가 얼마인지를 구하여 이를 출력하는 프로그램을 작성하시오.

5 7 3
0 2 4 4
1 1 2 5
4 0 6 2

3
1 7 13

풀이

• 직사각형을 제외한 구역의 넓이 구하기 -> 배열을 1로 채우고 직사각형 좌표에 0 등록
• DFS 사용하여 값 탐색(BFS 사용 가능)
• DFS 실행 후 넓이 리스트에 저장 후 sort() 사용하여 오름차순 정렬

코드

from collections import deque;

#  상하좌우 방향벡터
dx = [0,0,1,-1]
dy = [1,-1,0,0]

result = []     # 영역의 개수를 담는 리스트
cnt = 0         # 분리 영역 개수

# dfs를 실행될 때마다 분리된 영역 개수(cnt) 증가
# 해당 x, y 값 데크에 저장하고 방문 처리(False -> True)
def Dfs(x, y):
    cnt = 1
    q = deque()
    q.append((x, y))
    visited[x][y] = True

    # 큐가 비어있지 않다면, 해당 좌표의 상하좌우를 탐색
    while q:
        x, y = q.pop()
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]

            # 배열 인덱스를 넘지 않도록 범위 설정
            if nx < 0 or nx >= M or ny < 0 or ny >= N:
                continue
            # 탐색한 4방향의 값이 1이고 방문 리스트가 False일 경우 데크에 좌표값 저장 후 방문 처리, 영역 개수 증가
            if board[nx][ny] == 1 and not visited[nx][ny]:
                q.append((nx, ny))
                visited[nx][ny] = True
                cnt += 1

    return result.append(cnt)   # 오름차순 정렬 위해 영역 개수 리스트에 담고 반환

if __name__ == "__main__":
    # N: 가로 M: 세로 K: 분리 영역 개수(0으로 채울 부분)
    # 입력은 세로, 가로(M, N)를 받음

    M, N ,K = map(int, input().split())
    board = [[1] * N for _ in range(M)]
    visited = [[False] * N for _ in range(M)]

    # 분리할 영역 0으로 채우기
    for _ in range(K):
        x1, y1, x2, y2 = map(int, input().split())
        for i in range(y1, y2):
            for j in range(x1, x2):
                board[i][j] = 0

    # 해당 좌표가 1이고 방문하지 않았으면 DFS 실행 후 영역 수 증가시키기
    for i in range(M):
        for j in range(N):
            if board[i][j] == 1 and not visited[i][j]:
                Dfs(i ,j)
                cnt += 1


# 오름차순 정렬
result.sort()

print(cnt)      # 3

for i in result:
    print(i, end=' ')   # 1 7 13

유니티 프로젝트를 git으로 관리하다 프로젝트에 사용되는 파일이 삭제된 상태로 push 작업을 진행하였다.

파일을 복구하기 위해 이전 커밋으로 돌아가 그 파일만 복사해둔 뒤, 다시 프로젝트에 넣어줬다.

1. git log/git reflog

- 'git log' 혹은 'git reflog' 명령어를 입력하면 커밋 아이디를 확인할 수 있다. 불러오고 싶은 커밋 아이디를 복사해둔다.

git reflog

git log

2. git reset --hard [commitId]

reset --hard 명령어를 사용하여 이전 커밋으로 되돌릴 수 있다. 실행이 완료되면 파일 탐색기에서 지워졌던 파일을 따로 복사해둔다.

git reset --hard [commitId]

3. git status/git pull origin [branchName]

현재 프로젝트 상태를 확인해보면 pull 작업을 해야 한다 적혀있다. pull 받은 뒤 복사해둔 파일을 옮긴다.

git status
git pull origin [branchName]

Git Bash는 시각적인 부분이 전혀 없기 때문에 불편함을 많이 느낀다. 최근데 GitHub Desktop을 설치했는데, 명령어 사용 없이 사용할 수 있고 변경 사항이나 파일 추가 및 삭제를 한눈에 알아볼 수 있고, 몇 번 클릭만 하면 바로 깃에 업로드되기 때문에 매우 편리한 것 같다. 깃 데스크탑을 애용해야겠다. GitHub Desktop로 파일을 복구하는 방법은 아래 링크를 참고하면 된다.

GitHub Desktop으로 삭제 파일 복구하는 방법 링크

https://starlightbox.tistory.com/43

https://www.acmicpc.net/problem/4963

문제

정사각형으로 이루어져 있는 섬과 바다 지도가 주어진다. 섬의 개수를 세는 프로그램을 작성하시오.

한 정사각형과 가로, 세로 또는 대각선으로 연결되어 있는 사각형은 걸어갈 수 있는 사각형이다. 

두 정사각형이 같은 섬에 있으려면, 한 정사각형에서 다른 정사각형으로 걸어서 갈 수 있는 경로가 있어야 한다. 지도는 바다로 둘러싸여 있으며, 지도 밖으로 나갈 수 없다.

1 1
0
2 2
0 1
1 0
3 2
1 1 1
1 1 1
5 4
1 0 1 0 0
1 0 0 0 0
1 0 1 0 1
1 0 0 1 0
5 4
1 1 1 0 1
1 0 1 0 1
1 0 1 0 1
1 0 1 1 1
5 5
1 0 1 0 1
0 0 0 0 0
1 0 1 0 1
0 0 0 0 0
1 0 1 0 1
0 0

0
1
1
3
1
9

풀이

• 가로, 세로 또는 대각선으로 연결되어 있는 사각형은 걸어갈 수 있기 때문에 1개의 섬으로 취급
• 가로, 세로, 대각선 총 8개의 방향 벡터를 선언하여 DFS로 8방향 탐색하고, 섬의 개수 1 증가
• 입력의 마지막 줄에는 0이 2개 주어진다 -> 너비(w)와 높이(h)에 0을 입력하면 실행 종료: while문 사용하여 종료 조건 지정

코드

from collections import deque

# 상하좌우 대각선 방향
dx = [0,0,1,-1,1,1,-1,-1]
dy = [1,-1,0,0,-1,1,1,-1]

def dfs(x, y):
    # 위치 저장 후 데크에 넣고 방문처리
    q = deque()
    q.append((x, y))
    visited[x][y] = True
    
    # 큐가 비어있지 않다면, 맨 뒤에 있는 값의 상하좌우, 대각선 탐색
    # 주변 좌표에 섬이 존재할 경우 큐에 넣고 방문 처리
    while q:
        x, y = q.pop()
        for i in range(8):
            nx = x + dx[i]
            ny = y + dy[i]
            if nx < 0 or nx >= h or ny < 0 or ny >= w:
                continue
            if board[nx][ny] == 1 and not visited[nx][ny]:
                q.append((nx,ny))
                visited[nx][ny] = True

if __name__ == "__main__":
    while True:
        cnt = 0  # 섬의 개수
        w, h = map(int, input().split())    # 너비, 높이 입력
        board = [list(map(int, input().split())) for _ in range(h)]     # 지도 입력 받기
        visited = [[False] * w for _ in range(h)]   # 방문 체크 리스트
        
        # 입력값 '0 0'일 때 반복문 탈출
        if w == 0 and h == 0:
            break
        
        # 지도 탐색하며 섬이 있고, 방문하지 않았다면 dfs 실행 후 개수 증가
        for i in range(h):
            for j in range(w):
                if board[i][j] == 1 and not visited[i][j]:
                    dfs(i, j)
                    cnt += 1
        print(cnt)

https://www.acmicpc.net/problem/1303

5 5
WBWWW
WWWWW
BBBBB
BBBWW
WWWWW

130 65

풀이

• 같은 팀의 병사들은 모이면 모일수록 강해지며 제곱의 위력 가짐
• 같은 팀 병사들이 대각선으로 인접할 경우 뭉쳐있다고 보지 않기 때문에, BFS를 사용하여 상하좌우 탐색 후 병사의 수 저장
• 위력의 합 출력 위해 위력 더하는 변수 2개(blue, white) 선언
• BFS가 끝날 때, 위력 반환하여 모두 더한 뒤 출력
• strip(): 병사 입력 받을 때 문자열 공백 삭제 함수 사용

코드 

from collections import deque;

# 상하좌우
dx = [0,0,1,-1]
dy = [1,-1,0,0]

# 병사의 수
cnt = 0

# 병사의 옷 색 (W, B)
color = ''

# 아군, 적군의 위력으로 제곱해서 더할 변수
blue = 0
white = 0

def bfs(x, y, color):
    # 현재 들어온 병사를 큐에 넣기 때문에 병사의 수(cnt)를 1로 시작
    # 방문 처리 위해 현재 좌표값을 True로 변경
    # 큐에 넣은 좌표값을 꺼내어 상하좌우 탐색 -> 해당 값이 있고 방문하지 않았다면, 큐에 넣고 병사의 수 증가
    # 병사 n명 뭉쳐있을 경우 제곱근의 위력 -> cnt^2 반환 
    cnt = 1
    q = deque()
    q.append((x,y))
    visited[x][y] = True

    while q:
        x, y = q.popleft()
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]

            if nx < 0 or nx >= m or ny < 0 or ny >= n:
                continue
            if board[nx][ny] == color and not visited[nx][ny]:
                q.append((nx, ny))
                cnt += 1
                visited[nx][ny] = True  
    return cnt ** 2

if __name__ == "__main__":
    n, m = map(int, input().split())                        # 가로 세로 입력
    board = [list(input().strip()) for _ in range(m)]       # 병사의 옷 색 공백 없이 입력 받아 2차원 리스트 생성 
    visited = [[False] * n for _ in range(m)]               # 방문 확인 리스트

    for i in range(m):
        for j in range(n):
            if board[i][j] == 'W' and not visited[i][j]:    # 값이 'W'이고 방문하지 않았을 때 BFS 실행
                color = board[i][j]
                white += bfs(i, j, color)                   # 하얀 옷을 입은 병사의 위력 저장

            elif board[i][j] == 'B' and not visited[i][j]:  # 값이 'B'이고 방문하지 않았을 때 BFS 실행
                color = board[i][j]
                blue += bfs(i, j, color)                    # 파란 옷을 입은 병사의 위력 저장


print(white, blue)

https://www.acmicpc.net/problem/2667

문제

<그림 1>과 같이 정사각형 모양의 지도가 있다. 1은 집이 있는 곳을, 0은 집이 없는 곳을 나타낸다. 철수는 이 지도를 가지고 연결된 집의 모임인 단지를 정의하고, 단지에 번호를 붙이려 한다. 여기서 연결되었다는 것은 어떤 집이 좌우, 혹은 아래위로 다른 집이 있는 경우를 말한다. 대각선상에 집이 있는 경우는 연결된 것이 아니다. <그림 2>는 <그림 1>을 단지별로 번호를 붙인 것이다. 지도를 입력하여 단지수를 출력하고, 각 단지에 속하는 집의 수를 오름차순으로 정렬하여 출력하는 프로그램을 작성하시오.

풀이

• 단지에서 집이 있는 곳 즉, 값이 1일 경우 너비 우선 탐색(BFS)을 수행하여 해당 좌표의 상하좌우를 탐색하고, 단지내 집의 수를 리스트에 저장
• 단지수를 알아내기 위해 BFS 실행 횟수 저장
• sort(): 단지내 집의 수를 저장한 리스트(result)를 오름차순으로 정렬

코드

from collections import deque

N = int(input())

# 상하좌우
dx = [0, 0, 1, -1]
dy = [1, -1, 0, 0]
result = [] 
cnt = 0

def bfs(x, y):
    # bfs 실행 시 현재 위치의 값이 1이기 때문에 단지내 집의 수(cnt) 1로 설정
    # 데크 생성하여 단지가 있는(1) 위치 저장
    # 방문 처리를 위해 현재 위치값 0으로 변경
    cnt = 1
    q = deque()
    q.append((x, y))
    board[x][y] = 0

    # 상하좌우 탐색하여 해당 위치의 값이 1일 경우 데크에 위치 저장 후 단지내 집의 수 증가
    while q:
        x, y = q.popleft()
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if 0 <= nx < N and 0 <= ny < N:
                if board[nx][ny] == 1 :
                    board[nx][ny] = 0
                    q.append((nx, ny))
                    cnt += 1

    # 데크가 비었을 경우, 리스트에 단지내 집의 수 저장
    result.append(cnt)

if __name__ == "__main__":
    board = []
    for _ in range(N):
        board.append(list(map(int, input())))

    # 지도의 값이 1일 때, bfs 실행하고, 단지수 출력 위해 bfs 실행 횟수 cnt에 저장
    for i in range(N):
        for j in range(N):
            if board[i][j] == 1:
                bfs(i, j)
                cnt += 1

# 오름차순 정렬
result.sort()

# 단지 모임 출력
print(cnt)

# 단지수 출력
for i in result:
    print(i)

Shader "HJK/NewSurfaceShader"    // 쉐이더 이름
{
    // Properties: SubShader의 변수로 사용(_Color, _MainTex ...), 인터페이스 제작, 인스펙터에 노출됨
    Properties
    {
        //_Color ("Color", Color) = (1,1,1,1)
        //_MainTex ("Albedo (RGB)", 2D) = "white" {}

        // 광택, 재질(거침&매끈)
        //_Glossiness ("Smoothness", Range(0,1)) = 0.5
        //_Metallic ("Metallic", Range(0,1)) = 0.0
    
        _TestColor("TestColor", Color) = (1,1,1,1)
        _R ("Red", Range(0,1)) = 1
        _G ("Green", Range(0,1)) = 1
        _B ("Blue", Range(0,1)) = 1
        _BrightDarkness ("Bright & Darkness", Range(-1, 1)) = 0

        //// float
        //_Darkness ("Darkness", Range(0, 1)) = 0.5   // Range 함수: 슬라이더 바 생성
        //_Attenuation("Attenuation", Float) =  1.2   // float : 숫자 하나

        //// float4
        //_MyColor ("MyColor", Color) = (1,1,1,1)     
        //_Vector ("Vector", Vector) = (1,100,0.5,0)  

        //// Sampler: 대부분 텍스쳐
        //_MyTexture ("MyTexture", 2D) = "white"{}   // 이름{옵션}
    }

    // 실제 색상을 결정해줄 코드 작성
    SubShader   
    {
        Tags { "RenderType"="Opaque" }

        CGPROGRAM   
        // 1. 설정
        #pragma surface surf Standard fullforwardshadows noambient
        #pragma target 3.0

        //sampler2D _MainTex;

        // 2. 구조체: 유니티 엔진으로부터 받아와야 할 데이터(알아서 넣어줌)
        // 공란이면 안 됨
        struct Input
        {
            // : 시멘틱(CG가 UNITY 코드 알아들을 수 있게 해줌)
            float4 color : COLOR;
            //float2 uv_MainTex;
        };

        // * 변수 영역
        //half _Glossiness;
        //half _Metallic;
        fixed4 _Color;
        float4 _TestColor;
        float _R;
        float _G;
        float _B;
        float _BrightDarkness;
        //float4 test;

        // 3. 최종 픽셀 컬러 지정
        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            //float4 test = float4(1,0,0,1);  // 속성 rgba 집어넣어 색 표현 가능
            
            //float r = 1;
            //float2 gg= float2(0.5, 0);
            //float3 bbb = float3(1,0,1);
            //o.Albedo = float3(bbb.r, gg.r,r.r);
            //o.Albedo = _TestColor;
            o.Albedo = _TestColor + _BrightDarkness;
            
            //// Albedo comes from a texture tinted by color
            //fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
            //o.Albedo = c.rgb;
            //// Metallic and smoothness come from slider variables
            //o.Metallic = _Metallic;
            //o.Smoothness = _Glossiness;
            //o.Alpha = c.a;

            // 색 표현
            // Albedo: 빛 영향 O
            // Emission: 빛 영향 X
            //o.Albedo = float3(1, 0, 0);
            //o.Emission = float3(0.5,0.5,0.5) * float3(0.5,0.5,0.5);
            
        }
        ENDCG
    }

    FallBack "Diffuse"  // Diffuse: 유니티 내장 기본 셰이더
}

기본 셰이더 코드: _MainTex만 가지고 있다

Shader "Custom/tex"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}