SWIFT TIL카테고리에 올라와 있던 내용을 가져왔습니다.

2023 레츠스위프트 let's Swift 컨퍼런스에 참여했습니다. 같은 수강생분들, 러너분들, 단톡방에 계신분들을 만나서 너무 좋았고 행복했어요. 조만간 제대로 후기도 작성해보려고 합니다. 그전에 데일리로 기록을 남깁니다 :)

세션은 2~3개정도 오전에 듣고, 오후는 네트워킹시간으로 대부분을 보냈는데 세션도, 네트워킹도 즐겁고 알찬 하루였습니다. 동기부여도 많이 되고, 공부도(물론 오늘공부는 많이 못했지만) 더 열심히 하겠다는 다짐도 하게되었습니다.

너무 ios 초보라 갈까말까 고민했는데, 너무 가길 잘했다고 생각했습니다. 뉴비인데도 반겨주신 많은 분들 너무 감사드립니다. 내년의 레츠스위프트에서는 더 성장해서 저 역시 공유드리고 도움될 수 있는게 많아진다면 좋겠습니다 :)

컨퍼런스 목차

자세한 내용은 유튜브에 올라온다고 하니, 저는 가볍게 정리해서 공유해봅니다(기록 겸) (자세한 내용은 추후올라오는 유튜브를 참조해주세요)

들었던 세션

오픈소스 Swift - 이승준님

애플디벨로퍼아카데미 2기이신줄 몰랐으나, 나중에 알고 인사드릴수있어서 정말 주위분들에게도, 승준님께도 감사한 마음이었다. 일단 중간부터 들어서, 풀로 듣지못해 아쉽긴했지만 중간부터 들은 내용도 너무 좋았고, 개인적으로도 조금이라도 찍먹할 수 있도록 영어공부도 하고, 또 proposal에 지속적인 관심을 가져야겠다고 생각했던 세션, 또 아쉽게 못본 만큼 유튜브에 올라온 영상을 더 챙겨봐야겠다고 생각한 세션, 2기로 활동중이신데 이만큼 아웃풋을 벌써 내시는게 대단하다고 생각했다.

https://www.swift.org/swift-evolution/

path of Swift - 라이노님

문법을 공부하는 요즘 듣기 정말 적절했던 세션이었다. Swift 라는 언어가 어떻게 기계어(바이너리)가 되는지의 과정을 자세히 설명해주신 세션이었는데, 이러한 내용들을 잘 알고 있으면 나중에 문제해결을 할때 깊이가 달라지겠구나, 문법도 소홀히하지말고 실전도 소홀히 하지말아야겠다는 교훈도 얻었다.

전체과정 : PARSE => SEMA => SILGEN => SilOptimaize => IR => LLVM 

<PARSE>

Swift 사용시 => AST 추상부문트리를 만들어줘야함
AST를 올바르게 만들 수 있는가? Syntax analysis 구문분석
(기계어가 평서어를 이해하기 어려운 이유가 이때문 
=> swift 가 이해하기 쉽게 잘 정리해주는 역할을 함)
* Swift Language Reference공식문서에서 확인가능

매크로 - Swift Syntax 이 AST를 Swift 로 구현한 것 임 (최근나옴)

<SEMA>
AST => 올바르게 구성되어있는지 검사 : 타입검사, 구조적 검사 등등

아이텐티파이(식별자) 키워드로 구성 
- 키워드 : 컴파일러가 아는 단어
- 식별자 : 개발자들이 추가하고 만든것 
=> 컴파일러가 알지못함 
=> 선언, 정의를 통해 컴파일러가 이해해야함 (이 과정을 Name Lookup이라고 함) 
=> 선언, 정의는 다른 모듈에 있을 수 도 있음

문제점 발생 : 병렬로 돌리는 이유가 없어짐 선형적으로 돌아가는 구조 가 되버림 (어려워짐)
=> 컴파일러는 빠르게 뼈대로 파싱하고, 선언,정의는 Delayed Parsing 으로 필요할때 찾아가는 방식 (딱 필요한 만큼만 할당을 해주는것이 primary 파일을 할당하는 이유이고 이를 토대로 빠르게 파싱한 후 secondary 파일들은 delayed 파싱을 진행한다)


C컴파일러 특징 : 파일자체 컴파일링
C컴파일러 => 탑다운으로 읽어냄

Swift 컴파일러 => 탑다운 불가, 꼬여있음 => 체계화필요 
=> Swift 4.2에서 정보를 채워나가는 방식으로 Request Evaluator 도입됨 => 성능개선, 기능추가 됨

Swift 컴파일러 특징 : 모듈자체를 컴파일링

Swift 가 읽을 수 있는 모듈 
- 다른 Swift 로 되어있는 모듈(바이너리:읽기편하고 속도빠름 / 컴파일러에 종속적임 
=> 이를 해결을 위해 text형식의 SWift 인터페이스 파일을 사용하기도 함 )
- C C++ (클레이라는 프론트엔드 내장되있음) 모듈 (스위프트 선언으로 바꿔서 가져옴 : 스위프트 컴파일러 내부의 클레이 임포터가 바꿔줌) + 브릿징헤더
- LLVM 타입과 선언을 그대로 사용하는 모듈(표준라이브러리들만 사용가능함) 

<SILGEN>
스위프트 중간언어라는 의미 SIL swift - llvm 중간단계


<SilOptimaize>
최적화 진행  스위프트가 보장해주는 언어의 안정성이 여기서 검사가 됨
=> 최적화 검사완료 : Canonical SIL
+ 추가적인 최적화 옵션이 있다면 성능최적화를 함
=> 역시 Canonical SIL 로 변환

<IR>
IRGEN

<LLVM>
LLVM Backend => 최종적으로 바이너리로 출력됨

객체가 함수를 만났을때 - 권문범님

객체지향과 함수형을 합쳐서 아키텍쳐를 스스로 만들어보신 케이스, 설계능력을 키워볼 수 있고 개발자의 역량강화, 일단 너무 재밌었다는 말씀이 인상깊었다(정말 재밌어보였다) 언젠가 나도 아키텍쳐를 구현(도전)해보고싶다는 생각도 들었고, 여태까지 배웠던 문법내용(구조체, 열거형, 타입alias , 프로토콜, 확장, 함수, switch 문으로 패턴매칭, 타입선언, pirvate키워드, 계산속성,set블럭, lazy var, 메서드, super, override, self, self 로 라이프사이클 벗어나도 동작하도록 참조해주기 등등이 진짜 다 모여 하나의 작품을 만드는 느낌이었다. 제대로 다시 보고 이해하고싶은 세션

<객체지향> 
변경되는 단위를 캡슐화, 내부동작을 몰라도 설계가 쉽도록 
객체지향예시 : 클래스 메시지전달 상속 추상화 캡슐화 다형성 

Swift Concrete Type 
산재된 코드 ⇒ 설계, 재사용성 복잡해짐 ⇒ 추상화, 캡슐화 
내부동작을 몰라도 document 를 통해 재설계하고 만들수있다는 장점을 가짐

예시)
Singleton 패턴 : FileManager, URLSession
Decorator : UIScrollView-Table / UICollectionView
Composite : UIView -addSubView 
그외 등등…

<함수형> 
변경을 최소화해서 선언적으로 구현 / 실행예측이 쉽도록 지원
(사이드 이펙트 최소화, 코드로 바로 직관적 이해 가능하도록 : 
타입변경, 타입일치, 상태변경, 타입상태변경 등등) 

예시)
Pure Function
Functor/Monad (예 : Result) ⇒ Context + Value / map / faltMap / Optional

<객체지향과 함수형> 

PureFunction(인풋+로직 ⇒ 아웃풋) ⇒ 비동기환경에서의 무결성을 보장함 

객체지향 사용하면 좋은 예 : UI공유자원 => 캡슐화 사용필요 ( MVC 등) 객체지향에 속하게 됨 / Data, File, Network 

함수형 사용하면 좋은 예 : Result / Optional, Combine, Functions, 

<직접만들어보기>

오픈소스를 사용만 하지말고 ( swift 도 오픈소스다 ) 찾아보고 만들어보자 

아키텍쳐를 설계하기 앞서서 원하는 요소들 정리 (발표자님 기준)
- MVVM 아키텍쳐 : 멀티코어, 멀티쓰레드의 데이터 무결성보장가능(함수형을 잘 채용한다는 조건하에) 
- 결과에 따른 유연한 처리지원 
(한번에 결과를 받고, 처리할때만 성공,실패를 알수있도록,
실패의 원인을 바로 찍어줄 수 있도록)
- Flow의 가시성 
- 비동기 처리지원
- API Apple first party 사용

<원하는 요소를 적용하는 과정>
View / Interactor 
⇒ 어떤 Viewcontroller와 관계를 가지는지 선언 
ViewController view bind 및 lifecycle 
⇒ MVVM 의 핵심 (아래와 어떻게 연결할지)
ViewModel Dataflow 가시화 및 관리 
⇒ MVVM의 핵심(위와 어떻게 연결할지)
Data / network 비동기적 데이터 처리 
+) 프로토콜 지향 프로그래밍
구현단계에서 구현가능 , 관계정의도 편리함 
객체간의 인터페이스 선언 데이터 타입의 추상화 
- 라이프사이클의 앞부분 ⇒ 객체형 사용 + 프로토콜
- 라이프사이클의 뒷부분 => View model 과 데이터처리 사이에 함수형 적용 

+) Result 사용
HIG ⇒ 성공, 실패, 에러처리에 대한 명확성 강조 ⇒ Result 사용 장점 
에러타입 정의 ⇒ Result 의 Failure : 에러타입 으로 전달 


<결과물>
 미리 선언된것들을 한줄의 함수로 정리 ⇒ PURE한 함수가 됨 (외부인풋도 없고 로직은 탑다운으로 문제없이 진행됨) ⇒ 결과에 대한 유연성, flow 가시성, 유연성처리

<직접만든 아키텍쳐 사용해보기>
협업시 에러띄워주는게 가장효과적임
(이렇게 미리 타입선언 등을 다 해놓으면 자동으로 에러띄우고, 
자동완성을 해주니까 매우 효과적임)

당근ios

채용준비 하시는 분들이 제일 관심이 많으셨던것 같은 당근 ios 세션 기술적인 내용은 유튜브에서 더 자세히 설명을 들으실 수 있을것같고(절반정도 들었기 때문..!)

가장 궁금해하실것같은 당근ios에서 고민하고 있는 문제들을 공유합니다.

*고민하고 있는 문제들 (채용과 연계) *

<모바일팀>

- 계정, 알림, 데이터, 실험, 보안 등 서비스의 기반이 되는 코어기능 재설계
- 자동화, Horizontal Component개발을 통한 엔지니어 생산성 증대
- 도메인개발을 위한 안정적인 설계방향가이드

<채팅>
- 글로벌서비스(국내유저와 글로벌유저의 채팅경험 다름)
- 그룹채팅기능
- 동네생활 동네알바등 다양한 서비스 연동
- 다양한기능 가능한 유연한 구조 설계

제 기준으로 (정말 초보자기준) 정리한 내용들이라 실제 연사님의 의도와는 차이가 있을 수 있으니 유튜브로 진행되는 세션에서 더 정확한 정보를 얻어가는 시간 되시면 좋을것같습니다. 행사 제작하시느라 고생하신 오거나이저 분들, 스폰서분들, 연사분들, 또 참여하신 모든 참가자분들 고생많으셨습니다!

모두 즐거운 swift 되세요 :)

제스쳐 recognizer

 func addGestureRecognizers() {        
 // 탭 제스처 추가        
 let tapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(handleTap(gesture:)))        
 tapGestureRecognizer.delegate = self        
 sceneView.addGestureRecognizer(tapGestureRecognizer)        
 // 팬 제스처 추가 (드래그)        
 let panGestureRecognizer = UIPanGestureRecognizer(target: self, action: #selector(handlePan(_:)))        
 sceneView.addGestureRecognizer(panGestureRecognizer)        
 // 핀치 제스처 추가        
 let pinchGestureRecognizer = UIPinchGestureRecognizer(target: self, action: #selector(handlePinch(_:)))        
 sceneView.addGestureRecognizer(pinchGestureRecognizer)        
 // 롱프레스 제스처 추가        
 let longPressGestureRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(handleLongPress(_:)))        
 // 최소  2초동안은 프레싱되어야 제스쳐를 인식합니다        
 longPressGestureRecognizer.minimumPressDuration = 2        
 // 2초 안에 들어오는 제스쳐는 삭제합니다(버리기)        
 longPressGestureRecognizer.delaysTouchesBegan = true        
 sceneView.addGestureRecognizer(longPressGestureRecognizer)    
 }

제스쳐 함수 (오브젝트를 이동)

 @objc func handlePan(_ gesture: UIPanGestureRecognizer) {
    //  gesture.location(in: sceneView)는 제스처 이벤트가 발생한 터치 위치를 sceneView 좌표계에서 반환
    let location = gesture.location(in: sceneView)
    switch gesture.state {
    case .began:
        // 제스처의 상태를 확인합니다. 여기서는 제스처가 시작될 때(.began)만 코드를 실행합니다.
        let hitResults = sceneView.hitTest(location, options: nil)
        // sceneView.hitTest(location, options: nil)는 터치 위치(location)에서 히트 테스트를 수행하여 해당 위치에 있는 노드들을 반환(히트 테스트는 터치된 지점에 어떤 노드들이 있는지 확인하는 과정임)
        if let hitResult = hitResults.first {                
        selectedNode = hitResult.node
            //히트 테스트 결과에서 첫 번째 노드를 selectedNode로 선택합니다. hitResults.first는 히트된 노드들 중 첫 번째 노드를 반환합니다.
            while let parent = selectedNode?.parent, parent !== sceneView.scene.rootNode {                    
            selectedNode = parent
        }
            /* 
             - 선택된 노드의 최상위 부모 노드를 찾기 위해 `while` 루프를 사용합니다.                - `selectedNode?.parent`가 `nil`이 아니고, `selectedNode`의 부모가 `sceneView.scene.rootNode`가 아닐 때까지 루프를 계속 실행합니다.                - `selectedNode`를 계속 부모 노드로 갱신하여 최상위 노드에 도달할 때까지 반복합니다.                
              */
            originalNodePosition = selectedNode ? .position
        }
    case.changed: if
        let selectedNode = selectedNode,
        let originalNodePosition = originalNodePosition {
        // transition은 제스처 인식기에서 현재 팬 동작의 이동 거리를 가져옵니다. 이 거리는 사용자가 화면에서 손가락을 얼마나 이동했는지를 나타냅니다.
        let translation = gesture.translation(in: sceneView)                
        let newPosition = SCNVector3(                    
        x: originalNodePosition.x + Float(translation.x * 0.05),                    y: originalNodePosition.y + Float(translation.y * -0.05),                    z: originalNodePosition.z + Float(translation.y * -0.05)                
        )
        /*    
        - `translation` 값을 이용하여 `newPosition`을 계산합니다.                 - `originalNodePosition.x`에 `translation.x`을 더하여 노드의 새로운 x 위치를 계산합니다. `translation.x`에 0.001을 곱한 것은 화면상의 이동 거리를 3D 공간상의 이동 거리로 변환하기 위함입니다.                 - `originalNodePosition.y`는 그대로 유지됩니다. 이는 노드의 높이(y 축)를 변경하지 않음을 의미합니다.                 - `originalNodePosition.z`에 `translation.y`을 더하여 노드의 새로운 z 위치를 계산합니다. 마찬가지로 `translation.y`에 0.001을 곱한 것은 화면상의 이동 거리를 3D 공간상의 이동 거리로 변환하기 위함입니다.                 
        */
        selectedNode.position = newPosition
        // addAnimation(node: selectedNode)
        // addMoveUpDownAnimation(node: selectedNode)
    }
    case .ended, .cancelled:
        selectedNode = nil
        originalNodePosition = nil
    default:
        break
    }
}

제스쳐 함수 (오브젝트 스케일링)

@objc func handlePinch(_ gesture: UIPinchGestureRecognizer) {        
let location = gesture.location(in: (gesture.view as! ARSCNView))        
switch gesture.state {        
    case .began:            
    //  let hitResults = sceneView.hitTest(location, options: nil)            
        let hitTest = (gesture.view as! ARSCNView).hitTest(location)            
        if let hitTest = hitTest.first {                
        // 최상위 노드로 이동                
        selectedNode = hitTest.node
                while let parent = selectedNode?.parent, parent !== sceneView.scene.rootNode {  
                selectedNode = parent
             }                
                originalNodePosition = selectedNode?.position
            }        
            case .changed:            
                if let selectedNode = selectedNode, let originalScale = originalScale {     
                let scale = Float(gesture.scale)                
                selectedNode.scale = SCNVector3(x: originalScale.x * scale, y: originalScale.y * scale, z: originalScale.z * scale)            
                }        
                case .ended, .cancelled:            
                if let selectedNode = selectedNode 
                {                
                originalScale = selectedNode.scale
                   }        
            default:            
                break        
 }    
}

제스쳐 함수 (오브젝트 hidden)

    @objc func handleTap(gesture: UITapGestureRecognizer) {        
    let location = gesture.location(in: sceneView)            
    let hitResults = sceneView.hitTest(location, options: nil)            
    if let hitResult = hitResults.first {                
    selectedNode = hitResult.node
                while let parent = selectedNode?.parent, parent !== sceneView.scene.rootNode {                    
                selectedNode = parent
                }                
                originalNodePosition = selectedNode?.position
                originalScale = selectedNode?.scale
                if let selectedNode = selectedNode {                    
                for i in 1...64 {                        
                let nodeName = String(format: "Feu%02d", i) 
                if let fireNode = selectedNode.childNode(withName: nodeName, recursively: true) {                            
                if fireNode.isHidden {                                
                fireNode.isHidden = false                                
                playSound(currentModelName)                            
                }                            
                else 
                {                                
                fireNode.isHidden = true                                
                pauseSound(currentModelName)                            
                }                        
               }                    
             }                    
             let candleNodeName = "Cone_3"                    
             if let candleNode = selectedNode.childNode(withName: candleNodeName, recursively: true) {                        
             if let candleInnerNode = candleNode.childNode(withName: "Object_4", recursively: true) {                            
             if candleInnerNode.isHidden 
             {                                
             candleInnerNode.isHidden = false                                
             playSound(currentModelName)                           
             }                            
            else {                                
            candleInnerNode.isHidden = true                                
            pauseSound(currentModelName)                            
            }                        
           }                    
          }                    
          let starOrbNodeName = "inner_0"                    
          if let starOrbInnerNode = selectedNode.childNode(withName: starOrbNodeName, recursively: true) {                        
          if let starOrbCenterNode = starOrbInnerNode.childNode(withName: "Object_4", recursively: true) {                            
          if let starOrbNode = starOrbCenterNode.childNode(withName: "Object_0", recursively: true) {                                
          if starOrbNode.isHidden {                                    
          starOrbNode.isHidden = false                                    
          playSound(currentModelName)                                
          }                                
          else {                                    
          starOrbNode.isHidden = true                                    
          pauseSound(currentModelName)                                
          }                            
         }                        
        }                    
       }               
      }            
       }    
      }

제스쳐 함수 (오브젝트 애니메이션)

    @objc func handleLongPress(_ gesture: UILongPressGestureRecognizer) {        
    let location = gesture.location(in: sceneView)        
    switch gesture.state {        
    case .began:            
    let hitResults = sceneView.hitTest(location, options: nil)            
    if let hitResult = hitResults.first {                
    selectedNode = hitResult.node
                while let parent = selectedNode?.parent, parent !== sceneView.scene.rootNode {                    
                selectedNode = parent
        }                
                originalNodePosition = selectedNode?.position
                originalScale = selectedNode?.scale
                if let selectedNode = selectedNode {                    
                for i in 1...64 {                        
                let nodeName = String(format: "Feu%02d", i)            
                if let fireNode = selectedNode.childNode(withName: nodeName, recursively: true) {                            
                let scaleZAction = SCNAction.scaleZ(to: 5, duration: 5.0)                            adjustPivot(node: fireNode)                            
                fireNode.runAction(scaleZAction)                        
                }                    
                }                    
                let candleNodeName = "Cone_3"                    
                if let candleNode = selectedNode.childNode(withName: candleNodeName, recursively: true) {
                if let candleInnerNode = candleNode.childNode(withName: "Object_4", recursively: true) {                            
                let scaleYAction = SCNAction.scaleY(to: 5, duration: 5.0)                            adjustPivot(node: candleInnerNode)                            candleInnerNode.runAction(scaleYAction)                            
                if candleInnerNode.action(forKey: "scaleY") != nil {             
                let scaleYAction = SCNAction.scaleY(to: 1, duration: 5.0)
                //adjustPivot(node: candleInnerNode)                                candleInnerNode.runAction(scaleYAction)                            
                }                        
                }                    
                }                    
                let starOrbNodeName = "inner_0"                    
                if let starOrbInnerNode = selectedNode.childNode(withName: starOrbNodeName, recursively: true) {                        
                if let starOrbCenterNode = starOrbInnerNode.childNode(withName: "Object_4", recursively: true) {                            
                if let starOrbNode = starOrbCenterNode.childNode(withName: "Object_0", recursively: true) {                                
                let scaleAction = SCNAction.scale(to: 5.0, duration: 2.5)                        starOrbNode.runAction(scaleAction)       
                if starOrbNode.action(forKey: "scale") != nil { 
                let scaleAction = SCNAction.scale(to: 1.0, duration: 2.5)  
                starOrbNode.runAction(scaleAction)  
                }                            
                }                        
                        }                    
                    }                
                }            
            }        
            case .ended, .cancelled:            
            let hitResults = sceneView.hitTest(location, options: nil)            
            if let hitResult = hitResults.first {                
            selectedNode = hitResult.node
                while let parent = selectedNode?.parent, parent !== sceneView.scene.rootNode {                    
                selectedNode = parent
             }                
                originalNodePosition = selectedNode?.position
                originalScale = selectedNode?.scale
                if let selectedNode = selectedNode {                    
                for i in 1...64 {                        
                let nodeName = String(format: "Feu%02d", i)     
                if let fireNode = selectedNode.childNode(withName: nodeName, recursively: true) {                           
                if fireNode.action(forKey: "scaleZ") != nil {  
                let scaleZAction = SCNAction.scaleZ(to: 1, duration: 5.0)                        adjustPivot(node: fireNode)                                
                fireNode.runAction(scaleZAction)                            
                }                            
                fireNode.removeAllActions()                        
              }                    
            }                    
            let candleNodeName = "Cone_3"                    
            if let candleNode = selectedNode.childNode(withName: candleNodeName, recursively: true) {                        
            if let candleInnerNode = candleNode.childNode(withName: "Object_4", recursively: true) {                            
            candleInnerNode.removeAllActions()                        
            }                    
          }                    
          let starOrbNodeName = "inner_0"                    
          if let starOrbInnerNode = selectedNode.childNode(withName: starOrbNodeName, recursively: true) {                        
          if let starOrbCenterNode = starOrbInnerNode.childNode(withName: "Object_4", recursively: true) {                            
          if let starOrbNode = starOrbCenterNode.childNode(withName: "Object_0", recursively: true) {                                
          starOrbNode.removeAllActions()                            
          }                        
        }                    
      }                
    }            
  }            
  selectedNode = nil            
  originalNodePosition = nil            
  originalScale = nil            
  startY = nil            
  originalZScale = nil        
  default:            
      break        
   }    
  }

override func viewDidLoad() {
    super.viewDidLoad()
    // Set the view's delegate    sceneView.delegate = self
    // 씬 생성    let scene = SCNScene()
    // 씬 뷰에 SCNScene 인스턴스를 올림    sceneView.scene = scene
   // 인벤토리 버튼 추가    setupInventoryButton()
    // 제스처 인식기 추가    addGestureRecognizers()
}

 func loadUSDZModel(named modelName: String) {        
 // sceneView의 씬에서 루트 노드의 모든 자식 노드를 제거        
 // forEach 문으로 루트 노드의 모든 자식노드를 돌면서 씬의 루트 노드에 있는 모든 자식 노드를 제거함 
        sceneView.scene.rootNode.childNodes.forEach { 
        $0.removeFromParentNode() 
  }        
        guard let url = Bundle.main.url(forResource: "art.scnassets/\(modelName)", withExtension: "usdz"), let node = SCNReferenceNode(url: url) else { 
            print("USDZ 파일을 찾을 수 없습니다: \(modelName)")            
            return       
  }        
 // 일부 객체가 검게 보이는 현상이 있으므로 다시 조명추가해줌        
 // 씬에서 오브젝트를 갈아낄때 노드가 삭제되면서 조명(라이팅)이 제거된 것으로 보임        
 addLighting()        
 currentModelName = modelName
 // 소리를 재생합니다        
 playSound(modelName)        
 // 노드를 올립니다        
 node.load()        
 // Animated_fire 모델의 특성으로 z축으로 떨어져서 보내게 했습니다        
 node.position = SCNVector3(x: 0, y: 0, z: -15)        
 // 원하는 스케일로 조정        
 node.scale = SCNVector3(x: 0.15, y: 0.15, z: 0.15)        
 // 씬의 루트노드에 자식노드를 추가합니다        
 sceneView.scene.rootNode.addChildNode(node)        
 // 핀치 제스쳐 관련으로 selectedNode 속성을 사용했었으나 지금은 쓰지않음(일단 넣어뒀음 - 추후 삭제예정)        
 // selectedNode = node        
 // addAnimation(node: node)        
 originalScale = node.scale

 }

class ViewController: UIViewController, ARSCNViewDelegate, UIGestureRecognizerDelegate  {    
// ARKit과 SceneKit을 결합한 뷰로, ARKit을 사용하여 실제 환경을 추적하고 SceneKit을 사용하여 3D 콘텐츠를 렌더링하는 역할    
@IBOutlet var sceneView: ARSCNView!    
// ARSession 설정 함수    
func configureARSession() {    
//ARWorldTrackingConfiguration을 사용하여 디바이스의 위치와 방향을 추적하고, AR 콘텐츠를 실제 세계와 맞추는 설정을 함        
let configuration = ARWorldTrackingConfiguration()          
// 사람을 인식해서 사람 사이의 거리를 계산하여 객체를 위치시키는 기능          
// 장면에서 사람의 깊이와 관계없이 앱의 가상 콘텐츠에 사람이 겹쳐야 함을 나타내려면 personSegmentation 프레임 시맨틱을 사용합니다.          
// 객체를 강조하기 위해 해당 코드 생략가능(객체가 최상단에 오는것처럼 보입니다) 
configuration.frameSemantics.insert(.personSegmentation)        
// - ARKit가 디바이스의 위치와 방향을 추적하는 데 필요한 정보를 `detectionObjects` (ARKit이 감지할 객체의 목록) 으로 설정        
//- "AR Resources"라는 이름의 그룹에서 객체를 검색하되, nil로 설정하여 기본 번들을 사용하였음 , referenceObject가 nil을 반환할경우(목록이 nil일때) 빈배열 [] 사용       
configuration.detectionObjects = ARReferenceObject.referenceObjects(inGroupNamed: "AR Resources", bundle: nil) ?? []        
// - 세션은 ARKit이 현재 디바이스의 카메라 피드와 센서 데이터를 처리하고, 이를 기반으로 가상 콘텐츠를 렌더링하는 데 사용, 주어진 구성과 옵션을 사용하여 AR 세션을 시작함.        
// - .removeExistingAnchors로 기존 앵커를 제거하는 옵션 제공,새로운 세션이 시작될 때 이전 세션의 앵커를 모두 제거하여 초기 상태로 시작하게 하는 옵션        
// .resetTracking : 추적 상태를 리셋하는 옵션 설정, 새로운 세션이 시작될 때 디바이스의 추적 상태를 초기화하여  이를 통해 세션이 시작될 때 정확한 위치와 방향을 다시 설정할 수 있게함.        
sceneView.session.run(configuration, options: [.removeExistingAnchors, .resetTracking])    
}    
... }

ARKit 으로 세션을 설정하고 시작하는 과정 : ARWorldTrackingConfiguration을 사용하여 객체 감지를 설정하고 ARSCNView의 세션을 시작하는 코드조각 입니다.

추가 설정으로 객체를 감지하고, 디바이스의 위치와 방향을 추적하고, 감지된 객체를 기반으로 가상 콘텐츠를 렌더링하게 됩니다. 새로운 세션이 시작된다면 기존의 앵커와 추적 정보를 초기화하는 기능을 추가했습니다.

노드(물체) 씬에 올리기

override func viewDidLoad() {
    super.viewDidLoad()
    // Set the view's delegate    sceneView.delegate = self
    // 씬 생성    let scene = SCNScene()
    // 씬 뷰에 SCNScene 인스턴스를 올림    sceneView.scene = scene
   // 인벤토리 버튼 추가    setupInventoryButton()
    // 제스처 인식기 추가    addGestureRecognizers()
}

 func loadUSDZModel(named modelName: String) {        
 // sceneView의 씬에서 루트 노드의 모든 자식 노드를 제거        
 // forEach 문으로 루트 노드의 모든 자식노드를 돌면서 씬의 루트 노드에 있는 모든 자식 노드를 제거함        
 sceneView.scene.rootNode.childNodes.forEach { $0.removeFromParentNode() 
 }        
 guard let url = Bundle.main.url(forResource: "art.scnassets/\(modelName)", withExtension: "usdz"),let node = SCNReferenceNode(url: url) else {            
 print("USDZ 파일을 찾을 수 없습니다: \(modelName)")            
 return        
 }        
 // 일부 객체가 검게 보이는 현상이 있으므로 다시 조명추가해줌       
 // 씬에서 오브젝트를 갈아낄때 노드가 삭제되면서 조명(라이팅)이 제거된 것으로 보임        
 addLighting()        
 currentModelName = modelName
 // 소리를 재생합니다        
 playSound(modelName)        
 // 노드를 올립니다        
 node.load()        
 // Animated_fire 모델의 특성으로 z축으로 떨어져서 보내게 했습니다        
 node.position = SCNVector3(x: 0, y: 0, z: -15)        
 // 원하는 스케일로 조정        
 node.scale = SCNVector3(x: 0.15, y: 0.15, z: 0.15)        
 // 씬의 루트노드에 자식노드를 추가합니다        
 sceneView.scene.rootNode.addChildNode(node)        
 // 핀치 제스쳐 관련으로 selectedNode 속성을 사용했었으나 지금은 쓰지않음(일단 넣어뒀음 - 추후 삭제예정)        
 // selectedNode = node        
 // addAnimation(node: node)        
 originalScale = node.scale
 }

노드(물체)를 씬에 올렸다면 제스쳐를 적용해봅시다

해당 프로젝트에서는 기본적으로 UIkit 를 사용하므로 UIkit 에서 어떻게 핸드제스쳐를 이용하는지와 오브젝트를 제스쳐로 인식하는 방법을 설명합니다.

제스쳐를 인식하기 위한 제스쳐 recognizer을 viewDidLoad 부분에 올린 후, 해당 제스쳐가 인식되었을때 구동되는 함수를 따로 작성합니다

제스쳐 recognizer 로 제스쳐를 인식하게 합니다

예) 하단의 코드에서는 함수 handleTap / handlePan / handlePinch /handleLongPress 등이 그 역할을 수행하고 있습니다

 func addGestureRecognizers() {        // 탭 제스처 추가        let tapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(handleTap(gesture:)))        tapGestureRecognizer.delegate = self        sceneView.addGestureRecognizer(tapGestureRecognizer)        // 팬 제스처 추가 (드래그)        let panGestureRecognizer = UIPanGestureRecognizer(target: self, action: #selector(handlePan(_:)))        sceneView.addGestureRecognizer(panGestureRecognizer)        // 핀치 제스처 추가        let pinchGestureRecognizer = UIPinchGestureRecognizer(target: self, action: #selector(handlePinch(_:)))        sceneView.addGestureRecognizer(pinchGestureRecognizer)        // 롱프레스 제스처 추가        let longPressGestureRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(handleLongPress(_:)))        // 최소  2초동안은 프레싱되어야 제스쳐를 인식합니다        longPressGestureRecognizer.minimumPressDuration = 2        // 2초 안에 들어오는 제스쳐는 삭제합니다(버리기)        longPressGestureRecognizer.delaysTouchesBegan = true        sceneView.addGestureRecognizer(longPressGestureRecognizer)    }

• 롱프레스 제스쳐 셋팅 관련 공식문서 (참고용)

  UILongPressGestureRecognizer

  A continuous gesture recognizer that interprets long-press gestures.

  iOS 3.2+iPadOS 3.2+Mac Catalyst 13.1+tvOS 9.0+visionOS 1.0+

  @MainActor class UILongPressGestureRecognizer : [UIGestureRecognizer](https://developer.apple.com/documentation/uikit/uigesturerecognizer)

  개요

  UILongPressGestureRecognizer is a concrete subclass of UIGestureRecognizer. UILongPressGestureRecognizer는 UIGestureRecognizer의 구체적인 서브클래스입니다.

  The user must press one or more fingers on a view and hold them there for a minimum period of time before the action triggers. While down, the userʼs fingers canʼt move more than a specified distance or the gesture fails. 사용자는 동작이 트리거되기 전에 뷰를 하나 이상의 손가락으로 누르고 최소 시간 동안 유지해야 합니다. 누르고 있는 동안 사용자의 손가락이 지정된 거리 이상 움직이지 않으면 제스처가 실패합니다.

  A long-press gesture is continuous. The gesture begins (UIGestureRecognizer.State.began) when the user presses the number of allowable fingers (numberOfTouchesRequired) for the specified period (minimumPressDuration) and the touches don’t move beyond the allowable range of movement (allowableMovement). The gesture recognizer transitions to the Change state whenever a finger moves, and it ends (UIGestureRecognizer.State.ended) when the user lifts any of the fingers.

  길게 누르는 제스처가 계속됩니다. 제스처는 사용자가 지정된 기간(minimumPressDuration) 동안 허용되는 손가락 수(numberOfTouchesRequired)를 누르고 터치가 허용된 이동 범위(allowableMovement)를 벗어나지 않으면 시작됩니다(UIGestureRecognizer.State.began). 제스처 인식기는 손가락이 움직일 때마다 변경 상태로 전환되며, 사용자가 손가락을 떼면 종료(UIGestureRecognizer.State.ended)됩니다.

  • *Configuring the gesture recognizer* 제스처 인식기 구성하기

    var minimumPressDuration: TimeInterval

    The minimum time that the user must press on the view for the gesture to be recognized. 제스처를 인식하기 위해 사용자가 뷰를 눌러야 하는 최소 시간입니다.

    var numberOfTouchesRequired: Int

    The number of fingers that must touch the view for gesture recognition. 제스처 인식을 위해 뷰를 터치해야 하는 손가락의 수입니다.

    var numberOfTapsRequired: Int

    The number of taps on the view necessary for gesture recognition. 제스처 인식에 필요한 뷰의 탭 횟수입니다.

    var allowableMovement: CGFloat

    The maximum movement of the fingers on the view before the gesture fails. 제스처가 실패하기 전 뷰에서 손가락의 최대 움직임입니다.

    let lpgr = UILongPressGestureRecognizer(target: self, action: #selector(handleLongPress))lpgr.minimumPressDuration = 0.5lpgr.delaysTouchesBegan = truelpgr.delegate = selfself.colVw.addGestureRecognizer(lpgr)//MARK: - UILongPressGestureRecognizer Action -    @objc func handleLongPress(gestureReconizer: UILongPressGestureRecognizer) {        if gestureReconizer.state != UIGestureRecognizer.State.ended {            //When lognpress is start or running        }        else {            //When lognpress is finish        }    }

    핸들링을 더 잘하기위해 state를 받아서 began, changed, ended로 분기할 수 있다

    [추가개념]

  • delaysTouchesBegan*

    제스처 인식기가 시작 단계의 터치를 뷰로 전송하는 것을 지연시킬지 여부를 결정하는 부울 값입니다.

    var delaysTouchesBegan: [Bool](https://developer.apple.com/documentation/swift/bool) { get set } 이 속성의 값이 false(기본값)이면 뷰는 제스처 인식기와 병렬로 UITouch.Phase.began 와 UITouch.Phase.moved 터치 이벤트를 분석합니다. 이 속성의 값이 참이면 창은 UITouch.Phase.began단계의 터치 개체를 뷰로 전달하는 것을 일시 중단합니다. 이후 제스처 인식기가 제스처를 인식하면 이러한 터치 개체는 버려집니다. 그러나 제스처 인식기가 제스처를 인식하지 못하면 창은 터치의 현재 위치를 알려주는 후속 touchesMoved(_:with:)  메시지와 함께 이러한 개체를 뷰에 전달합니다( touchesMoved(_:with:)  메시지도 포함될 수 있음). 이 속성을 true로 설정하면 뷰에서 이 제스처의 일부로 인식될 수 있는 UITouch.Phase.began단계의 터치를 처리하지 않습니다.

해당 제스쳐를 인식했나요? 그럼 오브젝트에 변화를 줘 봅시다

기본적으로 SCNNode 에서 보듯 노드를 찾아서 오브젝트를 변경시킬 수 있습니다. 오브젝트의 위치, 오브젝트의 크기, 오브젝트내에서도 노드가 분리되어 있다면 특정노드(특정 콘텐츠)를 찾아 별개로 애니메이션을 적용할 수 있습니다.

예) 하단의 코드에서는 pan 제스쳐(꾹 누른 상태로 움직이는 제스쳐)에 따라 최상단 노드(최상단 노드가 아니면 일부 노드만/ 즉 오브젝트의 일부분만 옮겨질 수 있습니다)를 찾아서 제스쳐의 위치에 따라 오브젝트의 위치도 변경되는 코드가 구현되어 있습니다.

handlePan 메서드는 hitTest 결과로 반환된 노드의 최상위 부모 노드를 선택하여 이동합니다. 이를 통해 USDZ 모델의 전체 구조를 함께 이동할 수 있습니다.

좌표수정 : 오브젝트 이동 대충가능해짐

 @objc func handlePan(_ gesture: UIPanGestureRecognizer) {      //  gesture.location(in: sceneView)는 제스처 이벤트가 발생한 터치 위치를 sceneView 좌표계에서 반환        let location = gesture.location(in: sceneView)        switch gesture.state {        case .began:        // 제스처의 상태를 확인합니다. 여기서는 제스처가 시작될 때(.began)만 코드를 실행합니다.            let hitResults = sceneView.hitTest(location, options: nil)        // sceneView.hitTest(location, options: nil)는 터치 위치(location)에서 히트 테스트를 수행하여 해당 위치에 있는 노드들을 반환(히트 테스트는 터치된 지점에 어떤 노드들이 있는지 확인하는 과정임)            if let hitResult = hitResults.first {                selectedNode = hitResult.node
                //히트 테스트 결과에서 첫 번째 노드를 selectedNode로 선택합니다. hitResults.first는 히트된 노드들 중 첫 번째 노드를 반환합니다.                while let parent = selectedNode?.parent, parent !== sceneView.scene.rootNode {                    selectedNode = parent
                }                /*                - 선택된 노드의 최상위 부모 노드를 찾기 위해 `while` 루프를 사용합니다.                - `selectedNode?.parent`가 `nil`이 아니고, `selectedNode`의 부모가 `sceneView.scene.rootNode`가 아닐 때까지 루프를 계속 실행합니다.                - `selectedNode`를 계속 부모 노드로 갱신하여 최상위 노드에 도달할 때까지 반복합니다.                 */                originalNodePosition = selectedNode?.position
            }        case .changed:            if let selectedNode = selectedNode, let originalNodePosition = originalNodePosition  {                // transition은 제스처 인식기에서 현재 팬 동작의 이동 거리를 가져옵니다. 이 거리는 사용자가 화면에서 손가락을 얼마나 이동했는지를 나타냅니다.                let translation = gesture.translation(in: sceneView)                let newPosition = SCNVector3(                    x: originalNodePosition.x + Float(translation.x * 0.05),                    y: originalNodePosition.y + Float(translation.y * -0.05),                    z: originalNodePosition.z + Float(translation.y * -0.05)                )                /*                 - `translation` 값을 이용하여 `newPosition`을 계산합니다.                 - `originalNodePosition.x`에 `translation.x`을 더하여 노드의 새로운 x 위치를 계산합니다. `translation.x`에 0.001을 곱한 것은 화면상의 이동 거리를 3D 공간상의 이동 거리로 변환하기 위함입니다.                 - `originalNodePosition.y`는 그대로 유지됩니다. 이는 노드의 높이(y 축)를 변경하지 않음을 의미합니다.                 - `originalNodePosition.z`에 `translation.y`을 더하여 노드의 새로운 z 위치를 계산합니다. 마찬가지로 `translation.y`에 0.001을 곱한 것은 화면상의 이동 거리를 3D 공간상의 이동 거리로 변환하기 위함입니다.                 */                selectedNode.position = newPosition
                // addAnimation(node: selectedNode)                // addMoveUpDownAnimation(node: selectedNode)            }        case .ended, .cancelled:            selectedNode = nil            originalNodePosition = nil        default:            break        }    }

추가로 해당 코드에서 사용되는 개념 : translation / SCNVector3 을 아래에서 추가 설명합니다(공식문서 설명)

• 공식문서를 참조했습니다.

3D 게임을 만들고 앱에 3D 콘텐츠를 추가하고 애니메이션, 물리 시뮬레이션, 파티클 효과 및 사실적인 물리 기반 렌더링을 쉽게 추가할 수 있습니다.

class SCNScene SCNScene 클래스 표시 가능한 3D 씬을 구성하는 노드 계층 구조 및 전역 프로퍼티를 위한 컨테이너입니다. class SCNView SCNView 클래스 3D SceneKit 콘텐츠를 표시하기 위한 뷰입니다. class SCNNode SCNNode 클래스 지오메트리, 조명, 카메라 또는 기타 표시 가능한 콘텐츠를 첨부할 수 있는 3D 좌표 공간의 위치와 변환을 나타내는 씬 그래프의 구조적 요소입니다.

Scene Structure

Organizing a Scene with Nodes 노드로 씬 구성하기 : 노드를 사용하여 씬의 구조를 정의합니다.

SceneKit은 콘텐츠를 노드의 계층적 트리 구조(씬 그래프라고도 함)로 구현합니다. 씬은 씬의 월드 좌표 공간을 정의하는 루트 노드와 보이는 콘텐츠로 월드를 채우는 다른 노드로 구성됩니다.

SceneKit은 아래 그림과 같이 기본적으로 뷰 방향이 음의 z축을 따르는 오른손 좌표계를 사용합니다.

SCN노드 지오메트리, 조명, 카메라 또는 기타 표시 가능한 콘텐츠를 첨부할 수 있는 3D 좌표 공간의 위치와 트랜스폼을 나타내는 장면 그래프의 구조적 요소입니다.

SCN노드 객체 자체는 해당 객체가 포함된 씬이 렌더링될 때 표시되는 콘텐츠가 없으며 부모 노드를 기준으로 좌표 공간 변환(위치, 방향, 배율)만 나타냅니다. 씬을 구성하려면 노드 계층 구조를 사용하여 구조를 만든 다음 조명, 카메라 및 지오메트리를 노드에 추가하여 표시되는 콘텐츠를 만듭니다. 노드는 씬의 구조를 결정합니다. SceneKit을 사용하여 프로그래밍 방식으로 노드 계층 구조를 만들거나, 3D 제작 툴을 사용하여 만든 파일에서 계층 구조를 로드하거나, 두 가지 방법을 결합할 수 있습니다 노드의 어태치먼트가 시각적 콘텐츠와 동작을 정의합니다.노드 계층 구조는 씬의 공간적, 논리적 구조를 결정하지만 보이는 콘텐츠는 결정하지 않습니다.

class SCNReferenceNodeSCNReferenceNode 클래스 별도의 씬 파일에서 로드할 콘텐츠의 플레이스홀더 역할을 하는 씬 그래프 노드입니다. 참조 노드(SCNReferenceNode) 에 콘텐츠를 로드하도록 지시하면 SceneKit은 참조된 파일(referenced scene file)을 로드하고 파일의 루트 노드의 자식(scene file’s root node)을 참조 노드의 자식(children of the reference node.)이 되게 합니다.

rootNode 루트 노드 : 씬 그래프의 루트 노드var rootNode: [SCNNode](https://developer.apple.com/documentation/scenekit/scnnode) { get }

모든 씬 콘텐츠(노드, 지오메트리 및 해당 머티리얼, 조명, 카메라 및 관련 오브젝트)는 하나의 공통 루트 노드가 있는 노드 계층 구조로 구성됩니다.

이어서 , SceneKit 의 핵심요소 세가지, SCNView, SCNScene 과 SCNNode에 대해 설명하는 부분이 이어집니다.

(1) SCNScene

표시 가능한 3D 씬을 구성하는 노드 계층구조와 글로벌 프로퍼티를 위한 컨테이너입니다.

SceneKit으로 3D 콘텐츠를 표시하려면 시각적 요소를 함께 나타내는 노드 및 속성의 계층 구조가 포함된 장면을 만듭니다. 씬을 표시하려면 씬을 로드한 다음 SCNView의 씬 프로퍼티로 설정해야 합니다:

guard let myScene = SCNScene(named: "MyScene")
    else { fatalError("Unable to load scene file.") }scnView.scene = myScene // Your app's SCNView

ARWorldTrackingConfiguration

환경에 놓인 오브젝트와 관련하여 디바이스의 위치를 추적하는 구성입니다.

ARWorldTrackingConfiguration 클래스는 3개의 회전 축(롤, 피치, 요)과 3개의 이동 축(x, y, z 방향의 움직임)의 6자유도(6DOF)로 디바이스의 움직임을 추적합니다. 이러한 트래킹을 통해 몰입감 넘치는 AR 환경을 만들 수 있습니다: 사용자가 디바이스를 기울여 물체의 위나 아래를 보거나 디바이스를 움직여 물체의 측면과 뒷면을 보더라도 가상 물체는 현실 세계와 동일한 위치에 있는 것처럼 보일 수 있습니다. 후면 카메라를 사용하여 AR 환경을 표시하는 앱을 실행할때 해당 구성에 따라 세가지 옵션이 가능합니다.

월드 트래킹 세션이 카메라에 보이는 실제 장면의 요소를 인식하거나 상호 작용하는 방법

1. planeDetection : 실제 세계의 수평 또는 수직 표면을 찾습니다. 표면을 ARPlaneAnchor 오브젝트로 세션에 추가합니다.
2. detectionImages : 2D 이미지의 움직임을 인식하고 추적합니다. 2D 이미지를 ARImageAnchor 오브젝트로 장면에 추가합니다.
3. detectionObjects: 3D 객체를 인식합니다. 3D 오브젝트를 ARObjectAnchor 오브젝트로 장면에 추가합니다.

ARConfiguration

증강 현실 세션을 구성하는 방법에 대한 정보가 포함된 기본 객체입니다.

ARConfiguration은 AR 경험에서 구성할 수 있는 다양한 옵션에 대한 기본 클래스를 정의합니다. 앱에서 가상 콘텐츠와 라이브 카메라 이미지를 혼합하면 사용자는 가상 콘텐츠가 실제 세계의 일부인 것처럼 착각하게 됩니다.

• *Enable People Occlusion* 피플 오클루전은 카메라 피드에 있는 사람이 앱의 가상 콘텐츠를 가릴 수 있도록 하는 기능입니다. (1) 사람이 가상 콘텐츠보다 카메라에 더 가까이 있을 때 앱의 가상 콘텐츠와 겹치도록 할때

구성의 프레임 시맨틱에 personSegmentationWithDepth 옵션을 추가합니다.

if let config = mySession.configuration as? ARWorldTrackingConfiguration {    config.frameSemantics.insert(.personSegmentationWithDepth)    // Run the configuration to effect a frame semantics change.    mySession.run(config)}

1. 가상 객체 앞에 있는 사람은 가상 객체를 가리고, 가상 객체 뒤에 있는 사람은 가상 객체에 의해 가려지게 하고싶을때

장면에서 사람의 깊이와 관계없이 앱의 가상 콘텐츠에 사람이 겹쳐야 함을 나타내려면 대신 personSegmentation 프레임 시맨틱을 사용합니다. 이 옵션은 특히 그린 스크린 시나리오에 적합합니다.

(2)SCNView

SCNView

3D SceneKit 콘텐츠를 표시하기 위한 뷰입니다.

macOS에서 SCNView는 NSView의 서브클래스입니다. iOS 및 tvOS에서 SCNView는 UIView의 서브클래스입니다. 두 운영 체제의 뷰 계층 구조의 일부인 SCNView 오브젝트는 앱의 사용자 인터페이스에서 SceneKit 콘텐츠를 위한 공간을 제공합니다. SceneKit 보기에 콘텐츠를 제공하려면 해당 씬 프로퍼티에 SCNScene 객체를 할당합니다. SceneKit 뷰 작업에 대한 추가 중요 메서드 및 속성은 SCNSceneRenderer 프로토콜을 참조하십시오. (SCNRenderer 클래스를 사용하여 SceneKit 콘텐츠를 임의의 Metal 명령 대기열 또는 OpenGL 컨텍스트에 렌더링하거나 SCNLayer 클래스를 사용하여 macOS에서 코어 애니메이션 레이어로 렌더링할 수도 있습니다. SCNSceneRenderer 프로토콜은 세 가지 SceneKit 렌더링 클래스 모두에 공통된 기능을 정의합니다.)

Specifying a Scene

var scene: SCNScene? 뷰에 표시할 장면입니다.

(3) SCNNode

지오메트리, 조명, 카메라 또는 기타 표시 가능한 콘텐츠를 첨부할 수 있는 3D 좌표 공간의 위치와 트랜스폼을 나타내는 장면 그래프의 구조적 요소입니다.

SCN노드 오브젝트는 그 자체가 포함된 씬이 렌더링될 때 보이는 콘텐츠가 없으며, 부모 노드를 기준으로 좌표 공간 변환(위치, 방향 및 크기)만 나타냅니다. 씬을 구성하려면 노드 계층 구조를 사용하여 구조를 만든 다음 조명, 카메라 및 지오메트리를 노드에 추가하여 표시되는 콘텐츠를 만듭니다.

• *Nodes Determine the Structure of a Scene* 노드는 씬의 구조를 결정합니다 씬의 노드 계층 구조 또는 씬 그래프는 콘텐츠의 구성과 SceneKit을 사용하여 해당 콘텐츠를 표시하고 조작하는 기능을 모두 정의합니다. SceneKit을 사용하여 프로그래밍 방식으로 노드 계층 구조를 만들거나, 3D 제작 툴을 사용하여 만든 파일에서 계층 구조를 로드하거나, 두 가지 방법을 결합할 수 있습니다. 자세한 내용은 노드 계층 구조 관리 Managing the Node Hierarchy 및 노드 계층 구조 검색의 메서드 Searching the Node Hierarchy 를 참조하십시오.

씬의 루트노드 오브젝트  rootNode  는 SceneKit에서 렌더링되는 월드의 좌표계를 정의합니다. 이 루트 노드에 추가하는 각 자식 노드는 자체 좌표계를 생성하며, 이 좌표계는 차례로 자식 노드에 상속됩니다. 노드의 위치, 회전 및 배율 속성  position, rotation, and scale 을 사용하여(또는 트랜스폼 속성  transform을 직접 사용하여) 좌표계 간의 변환을 결정합니다.

• *A Node’s Attachments Define Visual Content and Behavior* 노드의 어태치먼트는 시각적 콘텐츠와 동작을 정의

노드 계층 구조는 씬의 공간적, 논리적 구조를 결정하지만 보이는 콘텐츠는 결정하지 않습니다. 노드에 SCNGeometry SCNGeometry오브젝트를 첨부하여 씬에 2D 및 3D 오브젝트를 추가할 수 있습니다. (지오메트리는 차례로 모양을 결정하는 SCNMaterial SCNMaterial 오브젝트를 첨부합니다.)

두번째 제스쳐인 팬 제스쳐 코드입니다. 마찬가지로 최상단 노드를 찾아 selectedNode로 설정하는 것은 같으나 오브젝트 전체를 드래그 즉 팬제스쳐를 통해 이동시키기 위해서는 최상단 노드를 찾는것으로 충분하기 때문에 추가로 자식노드를 찾는과정은 없습니다. 최상단 노드 , 즉 컨트롤 하기위해 필요한 노드를 찾았다면 팬제스쳐가 시작될때의 위치를 originalNodePosition 변수에서 저장해두었다가, 팬제스쳐가 실행, 즉 changed될때 sceneView에서 제스쳐가 변화된 만큼을 originalNodePosition기준으로 적절하게 계산하여 새로운 위치로 조정해줍니다. 여기서는 0.05를 곱하였고 z 축의 경우에는 따로 2D 좌표계인 제스쳐에서는 계산이 불가하여 적절한 위치로 보이도록 기존 z 축 위치에 y축 변화량을 계산해주는 방식으로 보완하였습니다.

제스처가 끝나는 ended 와 cancelled 의 경우에는 노드와 포지션의 값을 nil로 초기화 시켜줍니다.

유사한 과정을 거칩니다. 다만 여기서는 불꽃노드가 Feu01 부터 Feu64까지 복잡한 노드구성임을 확인했기 때문에 for 문을 통해 해당 노드들을 찾고 노드를 on/off 하는 로직으로 구성했습니다.

제스쳐를 활용하는 예시 두가지를 설명하겠습니다.첫번째는 탭제스쳐를 통해 노드를 찾아서 숨기는 기능입니다. 노드가 만약 프로젝트에서처럼 불꽃이라면 노드를 숨김으로써 불꽃이 꺼지고 켜지는 애니메이션을 구현할 수 있습니다. 첫번째 코드줄에서 sceneView에서의 제스쳐의 위치를 찾고, 히트테스트 메서드를 실행한 후에 테스트로 찾은 결과값을 hitResult의 복수형인 hitResults로 저장합니다. 히트 테스트는 주어진 2D 화면 좌표(여기서는 제스쳐를 통한 로케이션 좌표입니다) 에서 3D 공간의 객체를 검색하는 메서드로 히트테스트의 결과로 화면에서 가장 가까운 객체부터 차례로 배열에 담깁니다. hitResults 는 SCNHitTestResult 객체의 배열이 되고 장면 요소에 대한 장면 공간 또는 뷰 공간 검색 결과에 대한 정보가 담겨있습니다.

해당 배열의 첫 번째 요소를 가져와서 hitResult로 저장합니다. 첫 번째 요소는 화면에서 가장 가까운 객체를 나타냅니다. hitResult 요소에서 node 정보를 가져와서 selectedNode에 저장합니다.

이렇게 찾은 selectedNode 가 최상위 노드가 될때까지 while문을 반복한 후에 최상위 노드를 찾고 selectedNode로 설정하였으면 이제부터는 내가 찾는 노드이름이 나올때까지 childNode로 찾아 내려갑니다. 여기서는 Cone_3하위의 Object_4노드임을 scn파일 구조를 통해 확인했기 때문에 해당 노드를 찾습니다. candle의 불꽃을 찾아서 해당 노드가 hidden 상태라면 탭제셔쳐를 통해 보여지도록 보여지지않는 꺼진 상태라면 눌러서 켜지도록 로직을 구현했습니다.

🍰 두번째 코드조각

이제 씬을 올렸으니 위에 scenekit을 활용하여 노드를 위치시켜 오브젝트를 올릴 수 있습니다

여기서는 usdz 확장자를 가진 모델을 업로드하는 방법을 설명합니다.

해당 프로젝트에서는 우선 인벤토리에서 오브젝트를 꺼낼때마다 새로운 오브젝트를 위치시켜야 하므로 기존 오브젝트, 즉 노드를 삭제하도록 합니다. removeFromParentNode메서드를 통해 루트노드의 모든 자식노드를 제거해서 불필요한 기존 노드를 모두 삭제합니다. 이제 새로운 오브젝트를 올리기 위한 코드입니다.Bundle.main.url(forResource:withExtension:) 메서드를 사용하여 art.scnasset폴더내에 지정된 이름과 확장자를 가진 USDZ 파일의 URL을 가져온 후에 SCNReferenceNode(url: url)를 사용하여 해당 url 을 통해 SCNReferenceNode 를 만들고 node 에 저장합니다.이렇게 참조노드 형태로 만들면 방금과 같이 url을 통해 객체 인스턴스가 생성되는 즉시 로드되는것이 아닌 하단의 node.load() 함수처럼 load()메서드가 호출될때 콘텐츠가 로딩됩니다. 외부파일 즉, usdz파일들의 노드들은 이 참조노드의 자식노드가 됩니다. 그리고 가장 마지막 코드인 sceneView.scene.rootNode.addChildNode 를 통해 외부 usdz파일들의 노드를 가지고 있는 방금 생성한 참조노드 즉 node를 sceneView의 루트노드의 자식노드로 설정하면 씬에 위치시킬 수 있게 됩니다.

이 노드를 루트노드에 연결하기 전에 position과 scale 혹은 transform등의 속성을 통해 노드의 위치를 부수적으로 설정해줄 수 도 있습니다.

🍰 첫번째 코드조각

ARSCNView 클래스는 가상 3D 콘텐츠와 현실 세계의 기기 카메라 뷰를 혼합하는 증강 현실 경험을 만들기 위해 쓰이는 클래스입니다. 뷰에 제공된 ARSession 객체를 실행하면 sceneView는 자동으로 아이폰의 카메라 촬영장면을 앱의 배경으로 렌더링합니다. ARKit은 SceneKit의 좌표 공간을 실제 세계와 자동으로 일치시키기때문에 추후 씬킷에서 업로드하는 오브젝트와 ARKit 으로 구성된 카메라 뷰가 동적으로 반응하여 현실감을 더해줍니다. 앵커를 직접 생성하여 세션에 추가하거나 혹은 ARKit이 자동으로 생성하는 앵커를 사용하여 오브젝트를 씬에 위치할 수 있습니다. 해당 뷰를 main스토리보드에 깔고 해당 뷰를 뷰컨트롤러가 제어할수 있도록 ViewController 클래스 내부의 viewDidLoad 함수를 재정의할때 scene.delegate = self 로 설정합니다.

그리고 SCNScene 클래스의 인스턴스를 생성합니다. SCNScene 은 추후 3D 오브젝트를 올릴때 필요한 노드를 쌓기 위해 필요한 일종의 컨테이너 입니다. 노드가 올라가는 씬이라고 이해하면 좋습니다. 해당 씬이 동작하려면 SCNView의 scene 프로퍼티에 해당 씬을 설정해야합니다. scene프로퍼티는 뷰에 표시할 SceneKit 장면을 의미합니다. 따라서 sceneView.scene = scene 로 런타임에 노드들이 올라간 SCNScene씬이 표시되게 합니다.

viewWillAppear 재정의 함수 내에서는 ARkit 의 세션을 configuration으로 설정하고 run 메서드로 실행합니다. ARWorldTrackingConfiguration은 AR환경에 위치한 오브젝트와 실제 장면 요소의 인식과 관련된 설정을 진행할 수 있습니다. 여기서는 personSegmentation 시멘틱으로 설정하여 만약 두 사람이 있고 그 사이에 가상 객체가 있는 상황이라면 가상 객체 앞에 있는 사람은 가상 객체를 가리고, 가상 객체 뒤에 있는 사람은 가상 객체에 의해 가려지는 자연스러운 깊이감을 줄 수 있도록 셋팅하는 코드입니다.

해당 설정을 기반으로 세션을 실행합니다. 여기서 sceneView의 session프로퍼티는 뷰의 콘텐츠에 대한 모션 트래킹 및 카메라 이미지 처리를 관리하는 AR 세션을 의미하고 run 메서드로 실행가능합니다.

viewWillDisappear 재정의 함수내에서는 session의 pause 메서드가 실행되도록 하여 AR 세션을 일시 중지하여 불필요한 리소스 활용을 방지합니다

총 5편+9편 으로 구성 되어있습니다. ​

1) 5편의 시리즈가 끝난 후에는 2) 기능별 코드를 한줄한줄 주석을 포함해 9편(8+보너스)으로 공유할 예정입니다. ​ [코드조각으로 이해하기] [1편] ARKit 기초 설정 및 SCNScene 개념 소개 첫 번째 코드 조각 + AR 환경 설정 코드 + SCNScene 설명 [2편] 오브젝트 불러오기 & SCNReferenceNode 이해하기 두 번째 코드 조각 + 오브젝트 올리는 코드 + SCNNode 개념 [3편] 제스처: 탭으로 오브젝트 조작하기 세 번째 코드 조각 + 탭 제스처 핸들링 [4편] 제스처: 복잡한 노드 반복 제어하기 네 번째 코드 조각 + 롱프레스 제스처 핸들링 + Feu노드 컨트롤 예시 [5편] 팬/핀치 제스처로 오브젝트 이동/확대하기 & 정리 다섯 번째 코드 조각 + 팬/핀치 제스처 핸들링 ​ [기능별 코드(주석포함)으로 이해하기] [1편][AR 환경 설정을 위한 기본 구성] ARKit과 SceneKit을 결합한 View 설정 ARWorldTrackingConfiguration을 통한 디바이스 위치 및 방향 추적 사람 인식 및 객체 감지를 위한 프레임 시맨틱 설정 AR 세션 초기화 및 기존 트래킹 정보 제거 ​ [2편][SCNScene과 SCNView 초기 설정] SCNScene 인스턴스 생성 SCNView에 Scene을 바인딩 인벤토리 버튼, 제스처 등록 준비 ​ [3편][USDZ 오브젝트 불러오기 및 배치] 기존 노드 제거 SCNReferenceNode를 사용한 외부 모델 불러오기 모델 위치 조정 및 스케일 설정 씬에 노드 추가 조명 재설정 및 사운드 실행 포함 ​ [4편][제스처 인식기 등록] 탭(Tap) 제스처 팬(Pan) 제스처 핀치(Pinch) 제스처 롱프레스(LongPress) 제스처 ​ [5편][제스처 처리 함수 구현] 팬 제스처로 오브젝트 이동 핀치 제스처로 오브젝트 크기 조정 탭 제스처로 오브젝트 숨기기/보이기 롱프레스 제스처로 오브젝트 애니메이션 실행 ​ [6편][SceneKit의 핵심 클래스 개념 정리] SCNScene: 3D 씬 구조 및 속성 컨테이너 SCNView: 3D 콘텐츠를 렌더링하는 뷰 SCNNode: 씬 구조를 구성하는 기본 단위 SCNReferenceNode: 외부 파일을 참조하여 노드 불러오기 ​ [7편][AR 구성 관련 클래스와 설정 설명] ARWorldTrackingConfiguration을 통한 6자유도(6DOF) 추적 ARConfiguration의 기본 설정 개념 frameSemantics로 사람 인식 추가 옵션 설정 ​ [8편][SceneKit 애니메이션 처리 기초] SCNTransaction을 활용한 애니메이션 트랜잭션 처리 setAnimationDuration을 통한 암시적 애니메이션 적용 커스텀 트랜잭션으로 고급 애니메이션 구성 SCNVector3 구조체를 사용한 위치·크기 계산 ​ [보너스][제스처 구현 시 참고할 팁과 세부 동작 이해] hitTest를 사용하여 터치 지점의 노드 탐지 선택된 노드의 최상위 부모 노드를 찾아 전체 모델 이동 가능하게 설정 translation 값을 활용한 위치 변화 계산 delaysTouchesBegan 속성으로 터치 이벤트 처리 방식 조절 제스처 상태(state)에 따른 분기 처리: began, changed, ended, cancelled

초심을 잃지 않게 리마인드 되었던 시간이었기도하고, 여러모로 좋았다.

까먹지 않으려고 오픈된 곳에 남겨본다.

애정은 프로젝트를 지속하게 한다.

팀원에 대한 애정 프로젝트에 대한 애정

프로젝트에 대한 애정은 목표 얼라인의 중요성과도 연결된다. 팀빌딩 과정이 중요하다고 생각하는 이유중에 하나이다. 결국 공통된 비전과 목표를 가지고 있을때 해당 프로젝트에 대한 애정도 생기기 때문이다. 진행할 수록 내가 바라던 목표와 멀어지는 프로젝트라면 남아있던 애정마저 사라지기 쉽상일 것이다.

이와 비슷하게 프로젝트에 대한 애정없이도 팀원에 대한 애정으로 프로젝트가 지속되는 경우도 있을 것이다. 즉 팀에 대한 애정이 프로젝트를 지속하게 하는 이유라는 것이다.

짧은 경험이지만, 회사를 다니면서 내가 느꼈던 점은 팀에 애정을 갖게하는것도 그 팀의 역량이라는 것이다. 목표에 얼라인 할 수 있도록 끊임 없이 소통하는 것, 각자의 소통방식을 존중하면서 소통하는 것, 워킹스타일을 존중하면서 워킹하는 것, 그리고 팀 자체에 대한 애정을 지속할 수 있도록 소통하는 것. 이 모든것이 그 자체로도 팀의 역량이다.

훌륭한 팀은 개인을 적재적소에 잘 활용되게 만든다. 서로 윈윈하게 만든다. 애정을 주고받고 팀이 지속할 수 있도록 한다. 그리하여 결국 done 이 되도록 한다.

이러한 과정은 팀의 역량에 따른 것이다. 지속성 부족에 대한 문제는 단순한 개인의 일탈이나 개인의 역량의 부족만으로는 설명되지 않을때가 많다.

*앞으로 해야할 것 *

임의로 리터럴한 값을 코드에 박아서 필터링하는게 아니라 GUI에서 분류나 조건등을 선택해서 필터링한 값들을 화면에 보여줘야 함.

오랜만에 긴 시간 코딩을 했다. 물론 삽질이었지만...

알고리즘 스터디라도 하고 있어 다행이다 내가 맡은 부분은 삽입정렬 알고리즘이었다. 선택, 버블, 퀵, 카운팅 솔트를 배울 수 있었는데 시간복잡도와 공간복잡도의 개념, 그리고 각각의 장단점을 느끼고 구현방법을 익힐 수 있어 유익했다 :)

이름궁합

• 딕셔너리 사용
• 인덱스 당기기
• 유니코드 스칼라 값구하기

시간복잡도

sort, sorted 굳 메모리 두배되는 단점이 있을지도..?

듣보잡

• Array.contains => O(n)
• Set.contains => O(1)

Set이 유용한 예시

염색체

• if 대신 가드문사용
• 함수화 oneOrMore 함수로 체크

베스트셀러

• swift dictionary updatevalue
• 팔린책이 여러개일때 사전순으로 정렬할때 max 클로져
• 딕셔너리[readLine()!, default: 0] += 1

간지는 프로그래머스에서

updateValue

비슷한단어

• [[String]] 으로 문자 하나하나 받게 구성
• array로 알파벳의 포함개수

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

클래스로 풀기

https://solved.ac/class

에러가 발생했당

In a future version of the browser, cookies marked with SameSite=None; Secure and not Partitioned will be blocked in cross-site requests. This behavior protects user data from cross-site tracking. Please refer to the article linked to learn more about preparing your site to avoid potential breakage.

쿠키가 생성되지 않아서 페이지가 넘어가질 않는 나의 졸작

네트워킹 탭을 자세히 보니 url쪽에서 문제가 있는 것 같았다. 폴더를 옮기면서 폴더구조가 바뀌어서 api에서 못받아오는 것이였음

일단 코샌에서 잘 되는것은 확인했다.

밑 블로그들에서 알려준 samesite cookie 설정은 내 크롬브라우저에서 찾을 수 없어서

(크롬 구글에서 chrome://flags/ 검색) 일단 cookie 관련 설정을 enable 진행해주었는데 이것도 잘 돌아가게 된데 영향이 있었던 건지 알수없다..나중에 한번 해보자(눈물)

혹시를 대비해 담이 추천해준데로 readme 에 잘 돌아가는 코샌박스 링크를 첨부했다.

그리고 혹혹시를 대비해 vercel에 배포해보는 중인데, 대충아는 자가 어거지로 배포해서 그런지 배포가 요상해서 트라이 해보는 중. next 빌드쪽에서 경고가 나서 참고했던 스택오버플로우 글.. 경고문구는 다음과 같았다. You should not upload the .next directory.

https://stackoverflow.com/questions/50947389/nextjs-cannot-find-a-valid-build-in-the-next-directory

=> 다양하게 시도해봤는데 원본 깃을 건드리지않고(이미 제출했음) 해당 경고를 해결하면서도 정상적으로 쿠키가 만들어지는 경우가 없어서, 굳이 vercel로 배포하지는 않기로 결정했다.

처음에 났던 오류와 비슷하게 url쪽에서 오류가 나는데 뭔가 ..흠 배포할때 .next를 지워보고 배포하거나 아니면 폴더구조를 변경해서 root를 바꾸는 등 다른방식으로 배포를 해봐야할듯하다.

대신 잘 동작하는 코샌영상을 git read me 에 추가해서 혹시나 모를 오류를 방지하기로 했다

git 로 변경 후 issue를 이용해서 url을 구해서 영상을 올릴 수있는데 다음을 참고했다.

https://pgmjun.tistory.com/47

참고링크 (원래 설명을 써놨는데..chrom flags에서 설정을 변경하면서 velog가 날라가서 그냥 적는다)

https://darrengwon.tistory.com/647

https://velog.io/@mjooon98/Next.js-vercel%EC%97%90-%EB%B0%B0%ED%8F%AC%ED%95%98%EA%B8%B0

https://velog.io/@codns1223/Etc-Vercel%EB%A1%9C-React-%ED%94%84%EB%A1%9C%EC%A0%9D%ED%8A%B8-%EB%B0%B0%ED%8F%AC%ED%95%98%EA%B8%B0

오늘은 가볍게 근황 + 서로 고민했던 부분 공유

마치가 열거형을 한번 더 짚어주어서

1. 연관값과 원시값을 함께 쓸수없다는 것
2. 열거형을 그냥 RPS.rock 쓰는것과 RPS(rawvalue:3) 이렇게 쓰는것은 옵셔널에서 차이가 있다는 것

두가지를 리마인드 할수 있어서 준비해준 마치에게 고마웠다! 그리고 쏭님과도 즐거운 근황토크를 진행했다 :)

나는 velog 에 정리한 내가 고민했던 부분 위주로 공유를 진행함

알고리즘 스터디

리버가 내 git 셋팅부터 homebrew 설치와 git 연동까지 거의 40분 이상을 시간을 내서 도와주었다 (미리 20분전에 만났음에도...오버함) 너무 고맙고 볼때마다 대단한 리버쓰.. 홈브류

그리고 다른 스터디원분들도 대단하다고 항상 생각한다(나 저때 뭐했누 싶은 헤헷) 감사하고 인류애 충전하는 스터디 시간

알고리즘 스터디준비

알고리즘 문제 겨우 풀었(이걸 풀었다고 할수있을까...^_^) 다

*구밥이의 꿀팁 : 질문게시판을 잘 이용해보자! *

참고자료 링크

[iOS] Xcode DocC 사용법 [Swift] 알고리즘에 필요한 Swift Basic 총정리 공식문서 endIndex [iOS] swift 알고리즘, 코딩테스트에 필요한 tip 정리 파이썬의 enumerate() 내장 함수로 for 루프 돌리기

공식문서 enumerated() [백준][파이썬]1138번: 한 줄로 서기 스택오버플로우-Type Int does not conform to protocol sequence

결국 마지막에 백준용 제출법을 몰라 찾아봐야 했던

한 줄로 서기 - 백준 1138 - swift [출처] 한 줄로 서기 - 백준 1138 - swift|작성자 현무

모두모두 감사합니다 휴_휴

풀이를 마크다운으로 정리했다.

가볍게 일단 기록

알쓰 season2 - day1

문제 : 한줄로 서기 백준 1138번

N명의 사람들은 매일 아침 한 줄로 선다. 이 사람들은 자리를 마음대로 서지 못하고 오민식의 지시대로 선다.

어느 날 사람들은 오민식이 사람들이 줄 서는 위치를 기록해 놓는다는 것을 알았다. 그리고 아침에 자기가 기록해 놓은 것과 사람들이 줄을 선 위치가 맞는지 확인한다.

사람들은 자기보다 큰 사람이 왼쪽에 몇 명 있었는지만을 기억한다. N명의 사람이 있고, 사람들의 키는 1부터 N까지 모두 다르다.

각 사람들이 기억하는 정보가 주어질 때, 줄을 어떻게 서야 하는지 출력하는 프로그램을 작성하시오.

입력 풀이

첫째 줄에 사람의 수 N이 주어진다. N은 10보다 작거나 같은 자연수이다.

둘째 줄에는 키가 1인 사람부터 차례대로 자기보다 키가 큰 사람이 왼쪽에 몇 명이 있었는지 주어진다.

i번째 수는 0보다 크거나 같고, N-i보다 작거나 같다. i는 0부터 시작한다.

예제

/*

 4
 2 1 1 0
 >>>

 4 2 1 3

-----------
 5
 0 0 0 0 0
 >>>

 1 2 3 4 5


------------ 

 6
 5 4 3 2 1 0
 >>>

 6 5 4 3 2 1

  */

풀이

예제 하나를 풀어보자

/*
 4
 2 1 1 0

 >>>>>>>

 4 2 1 3
*/

첫번째 줄 의미 => 사람의 수 : 4명
두번째 줄 의미
=>
0번째 / 키가 1인 사람 : 왼쪽에 키가 큰 사람이 2명 xx1x   0010
1번째 / 키가 2인 사람 : 왼쪽에 키가 큰 사람이 1명 x2xx.  0210
2번째 / 키가 3인 사람 : 왼쪽에 키가 큰 사람이 1명 xxx3   0213
3번째 / 키가 4인 사람 : 왼쪽에 키가 큰 사람이 0명 4xxx   4213

즉 4213 출력

여기서 얻을 수 있는 힌트 : // 왼쪽에 몇명이 있는지 보고 그만큼 자리를 비우고 숫자를 채운다

// 입력을 받아오는 코드 

let totalNumber = Int(readLine()!)!
let array = readLine()!.components(separatedBy: " ").map { Int($0)!} 

// resultArray에 0일 채운다. [ 0 0 0 0 ] 을 만든다. (스위프트는 조금..귀찮게 만들어야함)

var resultArray: [Int] = []
for _ in 0..<totalNumber {
    resultArray.append(0)
}

// 반복문 + enumerated() 메서드를 이용해서 인덱스와 해당 인덱스의 요소를 튜플로 받는다. 

for (i, arrayNumber) in array.enumerated() {
    var count = 0
    /*i : 0 1 2 3   arrayNumber : 2 1 1 0

     왼쪽에 arrayNumber 명이 있을때
     1. 앞에 키 큰 사람을 그만큼 0이 비워져 있는지 확인하고, 비워져있다면 i+1을 채운다
     => 0 을 확인하고 0을 i+1 을 대체하는 행위는 resultArray 에서 일어나야하므로  
        루프를 한번 더 돌린다 */

    for (j, resultNumber)  resultArray.enumerated() {
         /*  j : 0 1 2 3   resultArrayNumber : 0 0 0 0

         2. 현재 갯수만큼(arrayNumber만큼) 0이 있는지 확인해야한다.  
            => 원하는 갯수의 0을 찾을 수 있을만큼 루프돌리기
            시도한 방법 1) j == arrayNumber 을 이용해서 조건이 성립할때까지 돌린다.
                      단 j == arrayNumber 을 이용해서 현재 갯수(arrayNumber) 만큼의  
                        0의 갯수를 확인하기 위한 루프를 돌리게 되면 
                        [0210] 인경우에서 빠져나감 (i 가 2 이고 키는 3 일때)
                        (i, arrayNumber) = (2,1) 왼쪽에 0은 한개여야 하는 루프에서  
                        동작하지 않는다
                        따라서 답이 [4 2 1 0] 으로 나오게 됨
                        따라서 원하는 횟수만큼 0을 확인하는 루프를 돌리려면
                        j == arrayNumber조건이 아닌 대체할 조건 하나가 더 필요하다
                        이 조건은 count 로 count 는 최종적으로는 2 1 1 0 즉 
                        arrayNumber와 같게된다. */

        // 0 이 있지만 아직 원하는 만큼의 arrayNumber 에 도달하지 못했다면

        if resultNumber == 0 &&  count < arrayNumber {
            // 해당 문이 실행되면서 count 를 올린다
            count += 1   
        }

        /*count를 arrayNumber 만큼 올려놓았으므로 이때  
         (내가 원하는 시점,  
         즉 왼쪽의 0의 갯수인 arrayNumber 과 올려놓은 count가 일치하는 시점에서)
         해당 else if 문이 실행된다.
         이때 그 자리에 i+1 을 넣는다(왜냐면 키는 1부터 시작, i 는 0부터 시작이기 때문이다)*/

        else if  resultNumber == 0 && count == arrayNumber {
            resultArray[j] = i+1
            break
           // 가장 가까운 for 문을 벗어난다 (바깥 for 문으로 돌아간다) 
        }
    }
}

// 다음과 같은 코드를 이용해서 하나하나 문자를 프린트 해줘야 백준에서 정답으로 인식가능 

resultArray.map({String($0)}).forEach{print($0, terminator : " " )}

내일 알고리즘(발등에 불떨어짐) 스터디를 위해 내가 선택한 한줄로 서기 문제를 보았다.

싸피를 준비했을 당시 배웠던 개념을 쓰는 문제인 것은 이해했는데, (구현문제를 골랐다) swfit 나 코드로 구현하기가 어려웠다.

이럴땐 답지를 보는게 상책이라(처음엔 다 이런거 아니겠는가..) 고민을 조금 해보다가 답지를 검색했다.

살짝 힌트를 얻어봤는데 일단 한번 돌려봐야겠다 싶어서 swift로 풀어보기로 결정했다.

우선 터미널에서 입력값을 받아오는 기초부터 시작해보자(난 알고리즘 유치원생이니까)

** 결론은 아래 링크에서 swift 로 백준풀기 글을 그냥 보시면 됩니다. **

학습

readLine() 이라는 유용한 이미 만들어진 메서드를 사용하면되는데 주의할점은 이 메서드의 리턴이 옵셔널 타입이라는 것이다.

func readLine(strippingNewline: Bool = true) -> String?

• 보다시피 strippingNewline 파라미터는 true 로 디폴트 설정이 되어있어서 엔터를 신경쓰지 않는다면 따로 설정할필요가 없다고한다 (공식문서 : strippingNewline => If true, newline characters and character combinations are stripped from the result; otherwise, newline characters or character combinations are preserved. The default is true) (true이면 결과에서 개행 문자 및 문자 조합이 제거되고, 그렇지 않으면 개행 문자 또는 문자 조합이 유지됩니다, 디폴트는true 입니다.)

(참고) 개행문자의 뜻

새줄 문자(newline)는, 텍스트의 한 줄이 끝남을 표시하는 문자 또는 문자열이다. 개행 문자, 줄바꿈 문자(line break), EOL(end-of-line)과 같은 뜻이다.

출처 : [https://adnetwork.tistory.com/18](개행 문자)

한마디로 엔터칠때 나타나는 문자를 표시해줄건지 말건지 인데, 디폴트인 true 로 두면(별다른 설정을 안하면) 제거한 값을 알려준다는 뜻이다.

*여하튼 리턴값이 String? 으로 옵셔널인것이 여기서는 중요하다. *

따라서 내가 참조한 블로그에서는 강제추출연산자 ! 를 사용해서 다음과 같이 옵셔널은 unwrapping 했다.

let input = readLine()!

하지만 궁금했다.

guard let 이나 if let 으로 unwrapping 하면 어떨까?

(왜 이러는거냐 도대체)

*참고로 혹시 끝까지 읽으실 분들이 있다면 그냥 강제추출연산자로 벗기시는게 가장 합리적일 것 같다는 결론에 이르렀다는 것을 안내드립니다. * (혹시 댓글로 관련 의견이 있다면 꼭 부탁드립니다..)

에러가 났다.

guard let input = readLine() else { return } // 에러발생 

print(input)

에러

Return invalid outside of a func

이유를 스택오버플로우를 참조해서 얻을 수 있었다(공식문서에서도 얻을 수 있었을지도 모른다)

참고한 스택오버플로우

여기에 따르면

If the condition in your guard statement is not met, the else branch has to exit the current scope. return can only be used inside functions, as the error message shows, but return is not the only way to exit scope.you can use throw outside functions as well and if the guard statement is in a loop, you can also use break or continue.

라고 한다. 요약해보면
에러의 원인은 에러메시지에서 보듯 함수내에 있지 않은데 return 을 써서 이다. 당연히!(바보같은 실수였네 아이코) 반환은 함수 내부에서만 사용할 수 있다.

해결방법

글에 따르면 반환만이 범위를 종료하는 유일한 방법은 아니며, 함수 외부에서도 throw를 사용할 수 있고 가드 문이 루프에 있는 경우 break 또는 continue를 사용할 수도 있다고 한다.

나는 다른 것은 복잡해보여서 throw 를 써보았다.

guard let input = readLine(strippingNewline: false) else { throw NSError() }

(break, continue 는 for 문 내에서 사용해야하고, return 은 함수를 따로 만들어 줘야한다)

결과

print("입력: ", terminator: "")
guard let input = readLine() else { throw NSError() }

print(input)

참고로 개행문자(newline) 을 포함하면 (strippingNewline: false 설정)

print("입력: ", terminator: "")
guard let input = readLine(strippingNewline: false) else { throw NSError() }

print(input)

다음과 같이 출력된다.

참고로 사실 변수는 문자열 보간법으로 사용할 수 있으므로(차이를 느꼈던 적이 있는데 지금 정확히 기억이 안나서 슬프다)

*굳이 guard let 을 쓸때의 코드는 다음의 코드가 더 정확하다고 생각한다 *

print("입력: ", terminator: "")
guard let input = readLine(strippingNewline: false) else { throw NSError() }

print("\(input)")

사실 제일 좋은 방법은 원 블로그처럼 강제추출연산자 ! 를 쓰는 것이다. NSError()를 굳이 해주는건 누가봐도 좋지 않을 듯 하다(뭔가 사이드 이펙트가 있을듯)

어차피 무조건적인 입력이 들어갈 예정이니까 모두 ! 를 사용하는게 어떨까..

** 결론 : 아래 링크에서 swift 로 백준풀기 글을 그냥 보시면 됩니다. **

우선 참조했던 자료들

백준 한줄로 서기 문제 파이썬 백준 한줄로 서기 풀이 스위프트로 백준풀기

나기님의 자료 Github PR관련