잉

아두이노(seeed Xiao) + 자석감지 센서 MLX90393 + 디스플레이 ST7789 TFT (2.0", 240×320) : 뮤토스코프 + 숨 프로젝트

잉_민 — Sun, 1 Mar 2026 11:54:25 +0900

뮤토스코프 인터랙티브 설치 — 프로젝트 정리

1. 주제

사람의 숨이 바람개비(이 안에 자석들어있음)를 돌리면, 자석 센서가 회전을 감지하고

그 주기에 따라 영상 재생 속도와 모터 속도가 실시간으로 반응하는 인터랙티브 설치 작품.

숨 → 바람개비(자석 회전) → MLX90393 감지 → 속도 계산 → 모터 PWM(뮤토스코프 회전) + TFT 스크린 영상 프레임 동기화

2. 방법론

전체 흐름

[숨 → 바람개비 회전]
    → 자석 센서: 회전 1회 감지
    → period(ms) 계산 (회전 주기)
    → 영상 속도: frameDelay = period / 21
    → 모터 속도: PWM = map(period, 500, 10000, 250, 190)
    → TFT: 21프레임 루프 재생

영상 재생 기준

원래 속도: 1초에 2장 (500ms/frame)
period = 10500ms일 때 frameDelay = 500ms → 2fps
빠른 숨 → period 짧음 → 빠른 영상 + 높은 PWM
느린 숨 → period 김 → 느린 영상 + 낮은 PWM

정지 감지

자석이 2초 이상 센서에 고정 → 정지 판정
정지 후 자석이 실제로 벗어날 때까지 재감지 차단 (waitingForRelease)
정지 시 lastTrigger = 0 리셋 → 다음 회전 감지 가능

3. 하드웨어

메인 보드

XIAO ESP32C6 (싱글코어, 160MHz)

센서: MLX90393 자석 센서

프로토콜: I2C
SDA: GPIO16, SCL: GPIO17
설정: GAIN_1X, RES_19(XY), RES_16(Z)
감지값 범위: magnitude 110~210 (자석 없을 때), 임계값 threshold = 160.0
폴링: 16ms (약 60Hz)

디스플레이: ST7789 TFT (2.0", 240×320)

프로토콜: 하드웨어 SPI (SPIClass(SPI))
CS: GPIO21, DC: GPIO22, RST: GPIO23, MOSI: GPIO18, SCK: GPIO19
SPI 속도: 40MHz
설정: rotation(1), invertDisplay(true)
이미지 위치: setAddrWindow(60, 20, 200, 200) → 320×240 화면 중앙
파일읽기: 27ms, 화면출력: 24ms → 총 51ms

모터: N20 소형 DC 모터

핀: GPIO0 (D0)
트랜지스터: 2N2222A (TO-18 금속캔)
PWM 범위: 190~250 (period 기반 자동 조정)
기동 최소 PWM: 200 이상

4. 회로도

[모터 회로]
ESP32C6 D0 ──[1kΩ]── 2N2222A 베이스
                      2N2222A 이미터 → GND
                      2N2222A 컬렉터 → 모터(-)
3.3V ──────────────── 모터(+)
모터 양단에 다이오드 (스트라이프→모터+)

[2N2222A TO-18 핀아웃]
탭 기준:
  탭 옆 = 이미터 → GND
  가운데 = 베이스 → 1kΩ → D0
  반대 = 컬렉터 → 모터(-)

[자석 센서 회로]
MLX90393 SDA → GPIO16
MLX90393 SCL → GPIO17
MLX90393 VCC → 3.3V
MLX90393 GND → GND

[TFT 회로]
TFT CS   → GPIO21
TFT DC   → GPIO22
TFT RST  → GPIO23
TFT MOSI → GPIO18
TFT SCK  → GPIO19
TFT VCC  → 3.3V
TFT GND  → GND
TFT BLK  → 3.3V (백라이트 ON)

5. 초기화 순서 (중요)

1. Wire.begin(16, 17)      // I2C 먼저
2. sensor.begin_I2C()
3. pinMode(MOTOR_PIN) + analogWrite  // 모터
4. spi->begin()            // SPI
5. LittleFS.begin()
6. tft.init()              // TFT 마지막

순서 틀리면 "센서 못찾음" 발생.

6. 영상 파일

경로: LittleFS /img_00.raw ~ /img_20.raw
포맷: RGB565 raw, 200×200px = 80,000 bytes
총 21프레임
바이트스왑 필수: frameBuf[i] = (val >> 8) | (val << 8)

최종 코드

#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>
#include <LittleFS.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_MLX90393.h>

#define TFT_CS   21
#define TFT_DC   22
#define TFT_RST  23
#define TFT_MOSI 18
#define TFT_SCK  19
#define MOTOR_PIN 0

#define IMG_WIDTH  200
#define IMG_HEIGHT 200
#define TOTAL_IMGS 21

SPIClass* spi = new SPIClass(SPI);
Adafruit_ST7789 tft = Adafruit_ST7789(spi, TFT_CS, TFT_DC, TFT_RST);
Adafruit_MLX90393 sensor = Adafruit_MLX90393();

uint16_t frameBuf[200 * 200];

float threshold = 360.0;
bool magnetPresent = false;
bool isStopped = false;
unsigned long lastTrigger = 0;
unsigned long frameDelay = 500;
int currentFrame = 0;
unsigned long lastFrame = 0;

void setup() {
  Serial.begin(115200);
  delay(3000);
  Serial.println("시작");

  Wire.begin(16, 17);
  if (!sensor.begin_I2C()) {
    Serial.println("센서 못찾음");
    while(1);
  }
  Serial.println("센서 OK");
  sensor.setGain(MLX90393_GAIN_1X);
  sensor.setResolution(MLX90393_X, MLX90393_RES_19);
  sensor.setResolution(MLX90393_Y, MLX90393_RES_19);
  sensor.setResolution(MLX90393_Z, MLX90393_RES_16);

  ledcAttach(MOTOR_PIN, 5000, 8);
  ledcWrite(MOTOR_PIN, 200);

  spi->begin(TFT_SCK, -1, TFT_MOSI, TFT_CS);
  LittleFS.begin(true);
  tft.init(240, 320, SPI_MODE0);
  tft.setSPISpeed(40000000);
  tft.setRotation(1);
  tft.invertDisplay(true);
  tft.fillScreen(ST77XX_BLACK);
  Serial.println("TFT OK");
}

void loop() {
  float x, y, z;
  if (sensor.readData(&x, &y, &z)) {
    float magnitude = sqrt(x*x + y*y + z*z);

    Serial.print("M:"); Serial.print(magnitude);
    Serial.print(" stopped:"); Serial.print(isStopped);
    Serial.print(" magnet:"); Serial.println(magnetPresent);

    // [1] 상승 엣지
    if (magnitude > threshold && !magnetPresent) {
      magnetPresent = true;
      unsigned long now = millis();
      Serial.println("---1---");

      if (isStopped) {
        isStopped = false;
        ledcWrite(MOTOR_PIN, 200);
        frameDelay = 500;
        Serial.println(">>> Restarting 200");
      } else if (lastTrigger > 0) {
        unsigned long period = now - lastTrigger;
        if (period > 500 && period < 10000) {
          frameDelay = period / 21;
          int pwm = map(period, 500, 10000, 250, 190);
          pwm = constrain(pwm, 190, 250);
          ledcWrite(MOTOR_PIN, pwm);
          Serial.print(">>> period: "); Serial.print(period);
          Serial.print(" PWM: "); Serial.println(pwm);
        } else {
          ledcWrite(MOTOR_PIN, 200);
          Serial.println(">>> period 범위 밖 200");
        }
      }
      lastTrigger = now;
    }

    // 자석 벗어남
    if (magnitude < threshold * 0.9) {
      magnetPresent = false;
    }
  }

  // [2] 마지막 회전 후 2초 = 정지
  if (!isStopped && lastTrigger > 0 && millis() - lastTrigger > 2000) {
    isStopped = true;
    lastTrigger = 0;
    magnetPresent = false;  // 여기
    ledcWrite(MOTOR_PIN, 0);
    Serial.println("---0--- PWM:0");
  }

  unsigned long now = millis();
  if (now - lastFrame > frameDelay) {
    char path[20];
    sprintf(path, "/img_%02d.raw", currentFrame);
    File f = LittleFS.open(path, "r");
    if (f) {
      f.read((uint8_t*)frameBuf, IMG_WIDTH * IMG_HEIGHT * 2);
      f.close();
      for (int i = 0; i < IMG_WIDTH * IMG_HEIGHT; i++) {
        uint16_t val = frameBuf[i];
        frameBuf[i] = (val >> 8) | (val << 8);
      }
      tft.startWrite();
      tft.setAddrWindow(60, 20, IMG_WIDTH, IMG_HEIGHT);
      tft.writePixels(frameBuf, IMG_WIDTH * IMG_HEIGHT);
      tft.endWrite();
    }
    currentFrame = (currentFrame + 1) % TOTAL_IMGS;
    lastFrame = now;
  }

  delay(16);
}

7. 시리얼 출력 형식

---1---   → 자석 감지 (한 바퀴)
---0---   → 정지 (2초 이상 고정)
period: 2000 frameDelay: 95 PWM: 235

8. 주요 해결 이슈 이력

문제 원인 해결

센서 못찾음	초기화 순서 잘못됨	I2C를 SPI보다 먼저
TFT 위에서 아래 렌더링	drawRGBBitmap 줄마다 호출	frameBuf + writePixels 한번에
TFT 화면출력 2169ms	소프트웨어 SPI	SPIClass(SPI) 하드웨어 SPI
정지 후 재감지 안됨	lastTrigger 리셋 안됨 + waitingForRelease 누락	정지 시 lastTrigger=0, waitingForRelease 플래그
모터 안돌음	PWM 너무 낮음	최소 200 이상

9. 정지 후 모터 재시작 문제 — 시행착오 전체 기록

목표

숨을 멈추면 모터 정지 → 다시 숨을 불면 모터 재시작

시행착오 목록

시도 1: 2초 고정 감지 자석이 센서 위에 2초 이상 머물면 정지 판정. 문제: 숨을 천천히 불면 정상 회전인데도 정지 판정남. magnetSinceTime 방식 자체가 틀림.

시도 2: analogWrite(MOTOR_PIN, 0) 모터 끄기. 문제: ESP32C6에서 analogWrite(pin, 0)은 LEDC PWM 채널 자체를 해제(detach)해버림. 이후 analogWrite(pin, 200) 호출해도 채널이 없어서 무반응.

시도 3: digitalWrite(MOTOR_PIN, LOW) PWM 채널 유지하면서 끄기 시도. 문제: LEDC PWM이 켜진 상태에서 digitalWrite는 무시됨. PWM이 핀을 장악하고 있어서 효과 없음.

시도 4: analogWrite(MOTOR_PIN, 10) 완전히 끄지 않고 최소값 유지. 문제: PWM 10은 모터가 돌기엔 너무 낮고 꺼지지도 않아서 모터가 버둥대며 전류를 계속 끌어당김 → 삐 소리 + ESP32C6 전력 불안정 → 렉.

시도 5: pinMode 재초기화 + delay 킥스타트

cpp

pinMode(MOTOR_PIN, OUTPUT);
analogWrite(MOTOR_PIN, 255);
delay(50);
analogWrite(MOTOR_PIN, 200);

문제: 채널이 이미 해제된 상태라 효과 없음.

시도 6: 정지 감지 방식 변경 "자석 2초 고정" → "마지막 회전 후 2초 동안 새 회전 없음"으로 변경. 개선됨. 하지만 재시작 여전히 안됨.

시도 7: ledcAttach + ledcWrite (최종 해결) analogWrite 완전히 제거하고 LEDC API 직접 사용. ledcWrite(pin, 0)은 채널 유지하면서 0 출력 → 채널 해제 안됨.

cpp

ledcAttach(MOTOR_PIN, 5000, 8);  // setup에서 한번만
ledcWrite(MOTOR_PIN, 200);       // 켜기
ledcWrite(MOTOR_PIN, 0);         // 끄기 (채널 유지)

문제: 재시작 여전히 안됨.

시도 8: magnetPresent 리셋 누락 발견 (최종 해결) ---0--- 후 magnetPresent = true 상태로 남아있어서 상승 엣지 조건 !magnetPresent가 영원히 안 걸림. 정지 시 magnetPresent = false 추가로 완전 해결.

cpp

if (!isStopped && lastTrigger > 0 && millis() - lastTrigger > 2000) {
  isStopped = true;
  lastTrigger = 0;
  magnetPresent = false;  // 핵심
  ledcWrite(MOTOR_PIN, 0);
  Serial.println("---0---");
}

결론

두 가지가 같이 해결되어야 했음:

analogWrite → ledcWrite 교체 (PWM 채널 유지)
정지 시 magnetPresent = false 리셋 (상승 엣지 재감지 가능하게)

시행착오들..

디스플레이: ST7789 TFT (2.0", 240×320)

GND → GND
VCC → 3.3V
SCL → D8
SDA → D10
RES → D5
DC → D4
CS → D3
BLK → 3.3V

MOSI 핀 번호를 17이라고 계속 우겼는데 18이 맞았어

바꾼 tft 되는거 빨강.

#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>
#include <SPI.h>

#define TFT_CS   21
#define TFT_DC   22
#define TFT_RST  23
#define TFT_MOSI 18   // D10 = GPIO18 (맞는 번호)
#define TFT_SCK  19   // D8 = GPIO19

Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCK, TFT_RST);

void setup() {
  tft.init(240, 280);
  tft.invertDisplay(true);
  tft.fillScreen(ST77XX_RED);
}

void loop() {}

영상출력

참고 : https://ing-min.tistory.com/323

#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>
#include <LittleFS.h>
#include <SPI.h>

#define TFT_CS   21
#define TFT_DC   22
#define TFT_RST  23
#define TFT_MOSI 18
#define TFT_SCK  19

#define IMG_WIDTH  200
#define IMG_HEIGHT 200
#define TOTAL_IMGS 21

Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCK, TFT_RST);
uint16_t lineBuf[200];

void drawRaw(int index) {
  char path[20];
  sprintf(path, "/img_%02d.raw", index);
  File f = LittleFS.open(path, "r");
  if (!f) return;
  for (int y = 0; y < IMG_HEIGHT; y++) {
    int bytesRead = 0;
    uint8_t* buf = (uint8_t*)lineBuf;
    while (bytesRead < IMG_WIDTH * 2) {
      int r = f.read(buf + bytesRead, IMG_WIDTH * 2 - bytesRead);
      if (r <= 0) break;
      bytesRead += r;
    }
    for (int x = 0; x < IMG_WIDTH; x++) {
      uint16_t val = lineBuf[x];
      lineBuf[x] = (val >> 8) | (val << 8);
    }
    tft.drawRGBBitmap(20, 40 + y, lineBuf, IMG_WIDTH, 1);
  }
  f.close();
}

void setup() {
  Serial.begin(115200);
  LittleFS.begin(true);
  tft.init(240, 280);
  tft.setRotation(0);
  tft.invertDisplay(true);
  tft.fillScreen(ST77XX_BLACK);
}

void loop() {
  for (int i = 0; i < TOTAL_IMGS; i++) {
    drawRaw(i);
    delay(80);
  }
}

영상이 위에서 아래로 선을 그리며 렌더링 되는문제

해결

ms (밀리초)

파일읽기: 27ms → LittleFS에서 80KB 읽는 시간
화면출력: 24ms → SPI로 TFT에 전송하는 시간

--디버깅 코드

#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>
#include <LittleFS.h>
#include <SPI.h>

#define TFT_CS   21
#define TFT_DC   22
#define TFT_RST  23
#define TFT_MOSI 18
#define TFT_SCK  19

#define IMG_WIDTH  200
#define IMG_HEIGHT 200
#define TOTAL_IMGS 21

SPIClass* spi = new SPIClass(SPI);
Adafruit_ST7789 tft = Adafruit_ST7789(spi, TFT_CS, TFT_DC, TFT_RST);
uint16_t frameBuf[200 * 200];

int currentFrame = 0;
unsigned long lastFrame = 0;

void setup() {
  Serial.begin(115200);
  delay(1000);

  spi->begin(TFT_SCK, -1, TFT_MOSI, TFT_CS);
  LittleFS.begin(true);
  tft.init(240, 320, SPI_MODE0);
  tft.setSPISpeed(40000000);
  tft.setRotation(0);
  tft.invertDisplay(true);
  tft.fillScreen(ST77XX_BLACK);
  Serial.println("TFT OK");
}

void loop() {
  unsigned long now = millis();
  if (now - lastFrame > 50) {
    char path[20];
    sprintf(path, "/img_%02d.raw", currentFrame);
    File f = LittleFS.open(path, "r");
    if (f) {
      f.read((uint8_t*)frameBuf, IMG_WIDTH * IMG_HEIGHT * 2);
      f.close();
      for (int i = 0; i < IMG_WIDTH * IMG_HEIGHT; i++) {
        uint16_t val = frameBuf[i];
        frameBuf[i] = (val >> 8) | (val << 8);
      }
      tft.startWrite();
      tft.setAddrWindow(20, 60, IMG_WIDTH, IMG_HEIGHT);
      tft.writePixels(frameBuf, IMG_WIDTH * IMG_HEIGHT);
      tft.endWrite();
    }
    currentFrame = (currentFrame + 1) % TOTAL_IMGS;
    lastFrame = now;
  }
}

되는 TFT 센서 코드

#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>
#include <LittleFS.h>
#include <SPI.h>

#define TFT_CS   21
#define TFT_DC   22
#define TFT_RST  23
#define TFT_MOSI 18
#define TFT_SCK  19

#define IMG_WIDTH  200
#define IMG_HEIGHT 200
#define TOTAL_IMGS 21

SPIClass* spi = new SPIClass(SPI);
Adafruit_ST7789 tft = Adafruit_ST7789(spi, TFT_CS, TFT_DC, TFT_RST);
uint16_t frameBuf[200 * 200];

int currentFrame = 0;
unsigned long lastFrame = 0;

void setup() {
  Serial.begin(115200);
  delay(1000);

  spi->begin(TFT_SCK, -1, TFT_MOSI, TFT_CS);
  LittleFS.begin(true);
  tft.init(240, 320, SPI_MODE0);
  tft.setSPISpeed(40000000);
  tft.setRotation(1);
  tft.invertDisplay(true);
  tft.fillScreen(ST77XX_BLACK);
  Serial.println("TFT OK");
}

void loop() {
  unsigned long now = millis();
  if (now - lastFrame > 50) {
    char path[20];
    sprintf(path, "/img_%02d.raw", currentFrame);
    File f = LittleFS.open(path, "r");
    if (f) {
      f.read((uint8_t*)frameBuf, IMG_WIDTH * IMG_HEIGHT * 2);
      f.close();
      for (int i = 0; i < IMG_WIDTH * IMG_HEIGHT; i++) {
        uint16_t val = frameBuf[i];
        frameBuf[i] = (val >> 8) | (val << 8);
      }
      tft.startWrite();
      tft.setAddrWindow(60, 20, IMG_WIDTH, IMG_HEIGHT);
      tft.writePixels(frameBuf, IMG_WIDTH * IMG_HEIGHT);
      tft.endWrite();
    }
    currentFrame = (currentFrame + 1) % TOTAL_IMGS;
    lastFrame = now;
  }
}

자석감지 센서

센서: MLX90393 자석 센서

프로토콜: I2C
SDA: GPIO16, SCL: GPIO17
설정: GAIN_1X, RES_19(XY), RES_16(Z)
감지값 범위: magnitude 110~210 (자석 없을 때), 임계값 threshold = 160.0
폴링: 16ms (약 60Hz)

MLX90393    XIAO
3V3  →  3.3V
GND  →  GND
SDA  →  D6 (GPIO16)
SCL  →  D7 (GPIO17)

두개 통합코드 (자석감지 , tft)

#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>
#include <LittleFS.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_MLX90393.h>

#define TFT_CS   21
#define TFT_DC   22
#define TFT_RST  23
#define TFT_MOSI 18
#define TFT_SCK  19

#define IMG_WIDTH  200
#define IMG_HEIGHT 200
#define TOTAL_IMGS 21

Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCK, TFT_RST);
Adafruit_MLX90393 sensor = Adafruit_MLX90393();

uint16_t lineBuf[200];
float threshold = 200.0;
bool magnetPresent = false;
unsigned long lastTrigger = 0;
float currentSpeed = 0;
int currentFrame = 0;
unsigned long lastFrame = 0;

void drawRaw(int index) {
  char path[20];
  sprintf(path, "/img_%02d.raw", index);
  File f = LittleFS.open(path, "r");
  if (!f) return;
  for (int y = 0; y < IMG_HEIGHT; y++) {
    int bytesRead = 0;
    uint8_t* buf = (uint8_t*)lineBuf;
    while (bytesRead < IMG_WIDTH * 2) {
      int r = f.read(buf + bytesRead, IMG_WIDTH * 2 - bytesRead);
      if (r <= 0) break;
      bytesRead += r;
    }
    for (int x = 0; x < IMG_WIDTH; x++) {
      uint16_t val = lineBuf[x];
      lineBuf[x] = (val >> 8) | (val << 8);
    }
    tft.drawRGBBitmap(20, 40 + y, lineBuf, IMG_WIDTH, 1);
  }
  f.close();
}

void setup() {
  Serial.begin(115200);
  Wire.begin(16, 17);  // SDA=D6, SCL=D7

  LittleFS.begin(true);

  tft.init(240, 280);
  tft.setRotation(0);
  tft.invertDisplay(true);
  tft.fillScreen(ST77XX_BLACK);

  if (!sensor.begin_I2C()) {
    Serial.println("MLX90393 못찾음");
  } else {
    Serial.println("MLX90393 OK");
    sensor.setGain(MLX90393_GAIN_1X);
    sensor.setResolution(MLX90393_X, MLX90393_RES_19);
    sensor.setResolution(MLX90393_Y, MLX90393_RES_19);
    sensor.setResolution(MLX90393_Z, MLX90393_RES_16);
  }
}

void loop() {
  float x, y, z;
  if (sensor.readData(&x, &y, &z)) {
    float magnitude = sqrt(x*x + y*y + z*z);

    if (magnitude > threshold && !magnetPresent) {
      magnetPresent = true;
      unsigned long now = millis();
      if (lastTrigger > 0) {
        float period = (now - lastTrigger) / 1000.0;
        currentSpeed = 1.0 / period;
        Serial.print("속도: ");
        Serial.println(currentSpeed);
      }
      lastTrigger = millis();
    }
    if (magnitude < threshold * 0.7) magnetPresent = false;
  }

  // 속도에 따라 재생 속도 조절
  float frameDelay = 80;
  if (currentSpeed > 0) {
    frameDelay = max(20.0, 150.0 / (currentSpeed * TOTAL_IMGS));
  }

  unsigned long now = millis();
  if (now - lastFrame > frameDelay) {
    drawRaw(currentFrame);
    currentFrame = (currentFrame + 1) % TOTAL_IMGS;
    lastFrame = now;
  }
}

자석 110- 310 값 범위.

Arduino IDE : xiao seeed esp32-c6 + TFT ST7789

잉_민 — Thu, 26 Feb 2026 11:13:02 +0900

XIAO ESP32C6 + ST7789 TFT 영상 재생 — 셋업 전체 기록

숨으로 바람개비를 돌리면 자석 센서가 회전을 감지하고, 그 주기에 맞춰 영상과 모터가 반응하는 인터랙티브 설치 작품을 만들면서 겪은 과정을 정리했다.

하드웨어

XIAO ESP32C6 (Seeed Studio)
ST7789 TFT 디스플레이 (2.0", 240×320)
MLX90393 자석 센서
N20 DC 모터 + 2N2222A 트랜지스터

1. 보드 설정

Arduino IDE에서 보드를 처음 잡을 때 ESP32 Family Device로 잡히는 경우가 있다. 이건 틀렸다.

ESP32 Family Device  ← 너무 넓은 분류, 핀 번호 등 세부 설정이 안 맞음
XIAO_ESP32C6         ← 정확한 모델 지정 필요

보드를 정확히 지정해야 GPIO 번호, 메모리 주소, 플래시 크기가 맞게 들어간다.

2. TFT 라이브러리 선택

처음에 TFT_eSPI 라이브러리를 시도했다. User_Setup.h에서 핀 번호를 직접 수정해야 하고 설정이 복잡하다. 결국 Adafruit_ST7789로 교체했다.

최종 사용 라이브러리: Adafruit_ST7789

이유:

설정이 단순하고 코드에서 직접 핀을 지정할 수 있음
하드웨어 SPI를 명시적으로 지정 가능
setSPISpeed() 지원

TFT 핀 연결

TFT XIAO ESP32C6

MOSI	D10 (GPIO18)
SCK	D8 (GPIO19)
CS	D3 (GPIO21)
DC	D4 (GPIO22)
RST	D5 (GPIO23)
BLK	3.3V

3. 소프트웨어 SPI vs 하드웨어 SPI

처음 Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCK, TFT_RST) 방식으로 초기화하면 소프트웨어 SPI로 동작한다. 화면 출력 시간이 2169ms가 나왔다.

하드웨어 SPI로 바꾸면 24ms로 줄어든다.

// ❌ 소프트웨어 SPI (느림, 2169ms)
Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCK, TFT_RST);

// ✅ 하드웨어 SPI (빠름, 24ms)
SPIClass* spi = new SPIClass(SPI);
Adafruit_ST7789 tft = Adafruit_ST7789(spi, TFT_CS, TFT_DC, TFT_RST);

// setup()에서
spi->begin(TFT_SCK, -1, TFT_MOSI, TFT_CS);
tft.init(240, 320, SPI_MODE0);
tft.setSPISpeed(40000000);

4. 영상 → TFT 출력 전체 파이프라인

전체 흐름

영상(mp4) → 프레임 추출(ffmpeg) → RGB565 변환(Python) → LittleFS 패키징 → Flash 업로드(esptool) → TFT 출력

Step 1. 영상 → 이미지 프레임 (ffmpeg)

5초 24fps 영상에서 6프레임마다 1장씩 총 21장 추출.

import subprocess, os, glob

videos = sorted(glob.glob("*.mp4"))

for video in videos:
    name = os.path.splitext(video)[0]
    output_dir = f"frames_{name}"
    os.makedirs(output_dir, exist_ok=True)
    
    cmd = [
        "ffmpeg", "-i", video,
        "-vf", "scale=200:200,select='not(mod(n\\,6))'",
        "-vsync", "vfr",
        "-q:v", "2",
        os.path.join(output_dir, "frame_%04d.jpg")
    ]
    subprocess.run(cmd)

Step 2. 이미지 → RGB565 변환 (Python)

TFT는 JPG를 직접 못 읽는다. 픽셀을 16bit 숫자로 변환한 .raw 파일로 저장해야 한다.

from PIL import Image
import os, glob, struct

input_dir = "frames"
output_dir = "data"
os.makedirs(output_dir, exist_ok=True)

files = sorted(glob.glob(os.path.join(input_dir, "*.jpg")))[:21]

for i, f in enumerate(files):
    img = Image.open(f).convert("RGB").resize((200, 200))
    pixels = []
    for r, g, b in img.getdata():
        rgb565 = ((b & 0xF8) << 8) | ((g & 0xFC) << 3) | (r >> 3)
        pixels.append(struct.pack("<H", rgb565))  # little-endian
    
    out_path = os.path.join(output_dir, f"img_{i:02d}.raw")
    with open(out_path, "wb") as out:
        out.write(b"".join(pixels))

Step 3. raw 파일 → LittleFS 이미지 (mklittlefs)

21개 .raw 파일을 하나의 littlefs.bin으로 패키징.

[Arduino 설치 경로]/packages/esp32/tools/mklittlefs/[버전]/mklittlefs \
  -c [data 폴더 경로] \
  -s 1966080 \
  -b 4096 \
  -p 256 \
  littlefs.bin

Step 4. littlefs.bin → XIAO Flash (esptool)

Flash의 0x210000 주소(SPIFFS/LittleFS 영역)에 직접 굽는다.

[Arduino 설치 경로]/packages/esp32/tools/esptool_py/[버전]/esptool \
  --chip esp32c6 \
  --port /dev/cu.usbmodem[포트번호] \
  --baud 921600 \
  write_flash 0x210000 littlefs.bin

Flash 메모리 구조

XIAO Flash 4MB
├── 0x000000  부트로더
├── 0x010000  스케치 (Arduino IDE로 업로드)
└── 0x210000  LittleFS (esptool로 업로드)
                  img_00.raw ~ img_20.raw

5. 이미지 출력 코드

❌ 잘못된 방법 (위에서 아래로 렌더링 보임)

// 줄마다 drawRGBBitmap 호출 → 스캔라인이 눈에 보임
for (int y = 0; y < IMG_HEIGHT; y++) {
    tft.drawRGBBitmap(x, y, lineBuf, IMG_WIDTH, 1);
}

✅ 올바른 방법 (한번에 전송)

uint16_t frameBuf[200 * 200];

// 전체 읽기
f.read((uint8_t*)frameBuf, IMG_WIDTH * IMG_HEIGHT * 2);

// 바이트 스왑 (색상 순서 보정)
for (int i = 0; i < IMG_WIDTH * IMG_HEIGHT; i++) {
    uint16_t val = frameBuf[i];
    frameBuf[i] = (val >> 8) | (val << 8);
}

// 한번에 전송
tft.startWrite();
tft.setAddrWindow(60, 20, IMG_WIDTH, IMG_HEIGHT);  // 중앙 배치
tft.writePixels(frameBuf, IMG_WIDTH * IMG_HEIGHT);
tft.endWrite();

6. 다른 장치들과 연결시 초기화 순서

TFT가 먼저 시작되면, 뒤에 통신들을 못받는 에러가 난다.

1. Wire.begin(SDA, SCL)       // I2C 먼저
2. sensor.begin_I2C()
3. ledcAttach(MOTOR_PIN, ...)  // 모터
4. spi->begin(...)             // SPI
5. LittleFS.begin()
6. tft.init()                  // TFT 마지막

AI Openclaw 오픈클로) 소형컴퓨터 버전 : zclaw +Seeed ESP32-C6/ S3

잉_민 — Thu, 26 Feb 2026 09:29:07 +0900

1. 프로젝트 공식 링크

zclaw는 아래의 깃허브(GitHub) 페이지에서 관리됩니다.

공식 깃허브: https://github.com/tnm/zclaw

GitHub - tnm/zclaw: Your personal AI assistant at all-in 888KiB (~25KB in app code). Running on an ESP32. GPIO, cron, custom too

Your personal AI assistant at all-in 888KiB (~25KB in app code). Running on an ESP32. GPIO, cron, custom tools, memory, and more. - tnm/zclaw

github.com

이곳에서 소스 코드를 확인하고, 이슈(질문/오류)를 제보하거나 업데이트 사항을 볼 수 있습니다.

2. 설치 및 빌드 방법 (C6 보드 타겟)

보유하신 ESP32-C6 보드를 기준으로, 가장 표준적인 설치 흐름입니다.

1단계: 환경 준비

컴퓨터에 ESP-IDF 환경이 구축되어 있어야 합니다. (VS Code에서 ESP-IDF Extension을 설치하면 가장 편리합니다.)

2단계: 코드 가져오기

터미널을 열고 다음 명령어를 입력합니다:

Bash

git clone https://github.com/tnm/zclaw.git

cd zclaw

3단계: 보드 설정 (Target 설정)

C6 모델을 사용한다고 환경에 알려주어야 합니다.

Bash

idf.py set-target esp32c6

4단계: 빌드 및 플래싱

다음 명령어를 순서대로 실행하여 코드를 보드에 올립니다:

Bash

# 코드 빌드 (컴파일)

idf.py build

# 보드에 업로드 (플래싱)

idf.py -p [컴포트번호] flash monitor

[컴포트번호]는 연결된 보드의 포트(예: COM3 또는 /dev/ttyUSB0)로 바꿔주세요.

3. 이해를 돕는 구조도

이 구조를 이해하시면 나중에 C6 보드에서 문제가 생겼을 때 어디가 잘못되었는지 찾기 훨씬 수월합니다.

⚠️ 주의사항 및 팁

메모리 최적화: 앞서 말씀드렸듯, C6는 PSRAM이 없기 때문에 menuconfig에서 메모리 사용 옵션을 최소화해야 할 수 있습니다. 빌드 시 오류가 발생하면 idf.py menuconfig를 실행하여 불필요한 기능(예: Wi-Fi 고도화 설정 등)을 끄고 다시 시도해 보세요.
로그 확인: idf.py monitor 명령어를 사용하면 보드가 어떤 오류를 내뱉는지 실시간으로 볼 수 있습니다. "Memory allocation failed" 같은 메시지가 뜬다면 메모리 부족이 원인이니, 더 가벼운 코드로 수정해야 합니다.

AI)OpenClaw 설치 & Gemini CLI + Telegram 연동 가이드 (mac)

잉_민 — Wed, 18 Feb 2026 09:06:52 +0900

https://youtu.be/ch4EsgfHOJc

1. OpenClaw 설치

curl -fsSL --proto '=https' --tlsv1.2 https://openclaw.ai/install.sh | bash

2. Gemini API 키 발급 (무료)

https://aistudio.google.com/app/apikey 접속
Google 계정 로그인
Create API key 클릭 → 키 복사

Claude API는 유료(pay-as-you-go)이므로 Gemini 무료 티어 사용 권장

3. OpenClaw 설정 (Gemini 연동)

openclaw configure

Model provider: Google CLI/ Gemini 선택

sudo npm install -g @google/gemini-cli

이거 설치해야함
발급받은 Gemini API 키 입력
기본 모델 추천: google/gemini-2.5-flash
- gemini-2.5-pro-preview-06-05는 무료 API에서 404 오류 발생하므로 사용 불가

4. Telegram 봇 생성

Telegram에서 @BotFather 검색
/newbot 입력 → 봇 이름 설정 (** 여기 봇으로 들어가야함: 검색으로 자신이 생성한 봇으로 채팅입장)
발급된 Bot Token 복사 → OpenClaw 설정에 입력

5. 게이트웨이 실행

openclaw gateway

이미 실행 중인 경우:

openclaw gateway stop   # 먼저 중지
openclaw gateway        # 재시작

6. Telegram 봇 페어링

Telegram에서 본인이 만든 봇 검색 (BotFather 아님!)
봇에게 /start 전송
봇이 페어링 코드 전송
터미널에서 아래 명령어로 승인:

openclaw pairing approve telegram 페어링코드

완료

이제 Telegram에서 본인 봇에게 메시지를 보내면 , 엄청기다리면, Gemini가 응답해요.

주요 명령어 정리

명령어 설명

openclaw gateway	게이트웨이 실행
openclaw gateway stop	게이트웨이 중지
openclaw status	게이트웨이 상태 확인
openclaw pairing list	대기 중인 페어링 요청 확인
openclaw pairing approve telegram <코드>	텔레그램 페어링 승인
openclaw models	모델 설정 변경
openclaw doctor	설정 오류 진단
openclaw dashboard	브라우저 대시보드 열기

C4D to Unity_ colth animation .abc 천 시뮬레이션 유니티로 보내기

잉_민 — Tue, 9 Dec 2025 03:22:44 +0900

shift +c 검색 : bake or alembic

선택 bake as alembic

경로지정하고 가서 보면 있음.

윈도우 -패키니 매니져 -unity registry : 인스톨 alembic

using UnityEngine;
using UnityEngine.Formats.Alembic.Importer;

public class AlembicLoop : MonoBehaviour
{
    AlembicStreamPlayer player;
    
    void Start()
    {
        player = GetComponent<AlembicStreamPlayer>();
    }
    
    void Update()
    {
        // CurrentTime은 0 ~ Duration 사이 값
        player.CurrentTime += Time.deltaTime;
        
        // Duration 넘으면 0으로 리셋 (루프)
        if (player.CurrentTime >= player.Duration)
        {
            player.CurrentTime = 0;
        }
    }
}

아래는 gpt가 가르쳐준 아주 쓸 때 없고 안되는 방법.

1) 시뮬레이션이 들어 있는 Cloth 오브젝트 선택

→ 오른쪽 Attribute Manager에서 Simulation 탭 열어.

2) 아래 항목 찾기:

Simulation → Scene → Cache

여기에서 반드시 다음 순서로:

3) Cache → Bake 클릭

→ 시뮬레이션이 메모리에 저장됨.

4) Cache → Convert to Mesh 또는 Export Cache

(C4D 2024 버전에서는 “Bake as Mesh” 같은 이름으로 나오기도 해)

이 기능이 시뮬레이션 결과를
프레임 단위 Mesh 캐시(Geometry Cache) 로 바꿔줘.

5) 이제 생성된 Mesh Cache를 선택

→ 이건 더 이상 Dynamic Simulation 오브젝트가 아니기 때문에
Animation → Bake Objects…가 활성화됨

6) Bake Objects 실행

옵션:

✔ PLA (Point Level Animation)
✔ Create Copy
✔ PSR 꺼도 됨

→ 이렇게 하면 시뮬 데이터가 PLA 애니메이션으로 굳음.

7) 마지막으로 FBX Export

FBX 옵션에서:

✔ Bake Animation ON
✔ Deformed Models ON

→ Unity에서 메시 애니메이션으로 재생됨.

in 유니티

점 애니메이션 안됨.

알렘빅으로 가져오면 바로됨.

VFX 파티클 시스템 : 용천수 영향권scalar map 시각화 + 하이트맵height map vfx적용

잉_민 — Mon, 8 Dec 2025 19:19:45 +0900

VFX 파티클 시스템 구현 완료

목표 1: 용천수 영향권 시각화

파티클이 용천수 근처를 지날 때 색상 변화

준비물

spring_distance.exr (Houdini 1025개 용천수 distance field)
해상도: 원본 비율 유지
값 범위: 0~20m

Unity 설정

SM_VictimPathVFX.cs:

// Spring map 파라미터
Vector3 springCenter = new Vector3(-2278, -4058.18091f, -2890) 
                     + new Vector3(-2644, -1356.30273f, 13395);
vfxGraph.SetVector3("MapCenter", springCenter);
vfxGraph.SetVector2("MapSize", new Vector2(43200, 58320));

VFX Graph - Blackboard

SpringDistanceMap (Texture2D)
MapCenter (Vector3)
MapSize (Vector2)
SpringThreshold (float) = 20.0

VFX Graph - Update Particle

1. UV 계산:
   Get Attribute: position → currentPos
   Subtract: currentPos - MapCenter → localPos
   Swizzle.xz: localPos → localPos2D (Vector2)
   Divide: localPos2D / MapSize → normalized
   Add: normalized + (0.5, 0.5) → springUV

2. Distance 샘플링:
   Sample Texture2D(SpringDistanceMap, springUV) → s
   Swizzle.x: s → distance

3. 색상 적용:
   Compare: distance < SpringThreshold → isNear
   Branch:
   ├─ True: (1, 0, 0, 1) ← 빨강
   └─ False: (0, 0, 0, 1) ← 검정
   → color
   
   Set Attribute: color

결과: 파티클이 용천수 20m 반경 지나갈 때만 빨간색 표시

목표 2: 지형 높이 따라가기

파티클이 제주도 지형을 따라 이동

준비물

jeju_height.tif (국토정보플랫폼 DEM)
해상도: QGIS 처리
높이 범위: 0~58m

Unity 임포트 설정

Texture Type: Default
sRGB: OFF
Compression: None
Format: R16
Wrap Mode: Clamp

Unity 설정

SM_VictimPathVFX.cs:

// Height map 파라미터
Vector3 heightCenter = new Vector3(-2278, -4058.18091f, -2890) 
                     + new Vector3(-9668, 0, 694);
vfxGraph.SetVector3("HeightMapCenter", heightCenter);
vfxGraph.SetVector2("HeightMapSize", new Vector2(28511.48f, 20509.97f));
vfxGraph.SetFloat("HeightMin", 0f);
vfxGraph.SetFloat("HeightMax", 58f);

VFX Graph - Blackboard

HeightMap (Texture2D)
HeightMapCenter (Vector3)
HeightMapSize (Vector2)
HeightMapRotation (float) = 180
HeightMin (float) = 0
HeightMax (float) = 58
HeightOffset (float) = 10

VFX Graph - Update Particle

1. 기본 경로 계산:
   age / lifetime → t
   Lerp(StartPosition, EndPosition, t) → pathPos

2. HeightMap UV 계산 (180도 회전):
   pathPos - HeightMapCenter → localPos
   Compose Vector2(-localPos.x, -localPos.z) → rotated
   rotated / HeightMapSize → normalized
   normalized + (0.5, 0.5) → heightUV

3. 지형 높이 샘플링:
   Sample Texture2D(HeightMap, heightUV) → heightSample
   Swizzle.x: heightSample → normalizedHeight
   Lerp(HeightMin, HeightMax, normalizedHeight) → terrainHeight
   Add: terrainHeight + HeightOffset → finalHeight

4. 최종 위치:
   Compose Vector3(pathPos.x, finalHeight, pathPos.z) → finalPos
   Set Position: finalPos

결과: 파티클이 XZ 경로는 유지하면서 Y값만 지형 높이를 따라감

핵심 포인트

좌표 변환 주의사항

Spring map: -90도 회전 = Swizzle(x, z)
Height map: 180도 회전 = (-x, -z)
Y 제거: Vector3 → Vector2 변환 시 Swizzle.xz

UV 계산 공식

1. Position - Center → localPos
2. 회전 적용 → rotated
3. / Size → normalized (월드 좌표 → 0~1)
4. + 0.5 → UV (중심 맞추기)

파티클 생성 방식

Periodic Burst:
- Count: VictimPathCount (9653)
- Delay: 2초
- Loop: Infinite
- Capacity: VictimPathCount × 5

완성!

1 height map (0-1범위)

2.용천수 , 스칼라 맵 set color

Houdini _ geo json 위도경도, 특정 지점 주변으로 Scalar Field (스칼라 필드)생성

잉_민 — Mon, 8 Dec 2025 03:22:56 +0900

제주 4·3 용천수 Scalar Field 생성 문서

Scalar Field (스칼라 필드)
각 복셀에 숫자 하나 (0~1)
용천수까지 거리/영향도

목적

제주 지형에서 각 지점으로부터 가장 가까운 용천수까지의 거리를 계산하여 텍스처로 출력. Unity VFX Graph에서 파티클이 용천수로 끌려가는 효과에 사용.

데이터

제주 지형: HeightField (1080 x 1800, 높이 ~50)
용천수 포인트: 1025개, GeoJSON에서 로드하여 제주 좌표계로 변환됨

Houdini 노드 체인

1. heightfield_file1 (제주 지형 로드)
2. python (용천수 GeoJSON 로드)
3. transform (좌표 변환)
4. pointwrangle1 (용천수를 지형 높이로 올림)
   └─ 코드: pos.y = volumesample(1, "height", pos);

5. HeightField Copy Layer
   └─ Source: height
   └─ Destination: spring_dist

6. Volume Wrangle (거리 계산)
   └─ 입력 1: HeightField (height, mask, spring_dist)
   └─ 입력 2: 용천수 포인트

7. HeightField Remap (0-1 정규화)
   └─ Input Min: 578.666
   └─ Input Max: 1796.660
   └─ Output Min: 0
   └─ Output Max: 1

8. HeightField Output (EXR 저장)

Volume Wrangle 코드

if (@primnum == 2) {
    float total = 0.0;
    float radius = 20.0;  // 20m
    
    for(int i = 0; i < 1025; i++) {
        vector sp = point(1, "P", i);
        
        float dx = @P.x - sp.x;
        float dz = @P.z - sp.z;
        float dist = sqrt(dx*dx + dz*dz);
        
        if (dist < radius) {
            total += 1.0 - (dist / radius);
        }
    }
    
    f@spring_dist = clamp(total, 0.0, 1.0);
}

코드 설명

@primnum == 2: spring_dist 레이어만 처리 (primitive 2번)
volumeindextopos(): 복셀 인덱스를 월드 좌표로 변환
npoints(1): 두 번째 입력(용천수 포인트) 개수
point(1, "P", i): 용천수 포인트 위치 가져오기
XZ 평면 거리만 계산: 높이 차이 무시

주요 문제와 해결

문제 1: s@name 작동 안 함

증상: if (s@name == "spring_dist") 조건이 실행 안 됨

원인: HeightField의 volume primitive는 name 속성이 비어있음

해결: @primnum으로 직접 지정

primitive 0 = height
primitive 1 = mask
primitive 2 = spring_dist

HeightField Output 설정

Output Type: Deep Raster
Type: 32b Floating Point
Filename: $HIP/spring_distance.exr
Layers: spring_dist

내보내기:

HeightField Output 노드 선택
"Save to Disk" 버튼 클릭
$HIP/spring_distance.exr 파일 생성됨

Unity 사용법

1. 텍스처 Import

spring_distance.exr를 Unity 프로젝트로 드래그

2. VFX Graph에서 사용

Sample Texture2D
├─ Texture: spring_distance
├─ UV: Particle Position (XZ를 0-1로 정규화)
└─ Output: distance (float)

Force
└─ Direction: 용천수 방향으로 계산
└─ Strength: 1.0 - distance (가까울수록 강함)

3. 값 해석

0 (검은색): 용천수 바로 근처 → 최대 끌림
1 (흰색): 용천수에서 가장 멀리 → 최소 끌림

결과물

파일: spring_distance.exr (32-bit floating point, single channel)
해상도: 540 x 900 (HeightField 해상도와 동일)
값 범위: 0.0 ~ 1.0 (정규화됨)
의미: 각 복셀에서 가장 가까운 용천수까지의 2D 거리

참고사항

2D 수평 거리만 계산 (Y축 높이 무시)
용천수 포인트 개수: 1025개
거리 원본 범위: 578 ~ 1796 (미터 단위)

원인

Volume Wrangle에서 npoints(), nprimitives() 같은 geometry 쿼리 함수가 두 번째 입력에 대해 제대로 작동하지 않음.

해결

직접 loop으로 point 개수 확인하거나, 알고 있는 개수 하드코딩:

// ✅ 해결책 1: 알고 있는 개수 사용
for(int i = 0; i < 1025; i++) {
    vector sp = point(1, "P", i);
    // ...
}

// ✅ 해결책 2: loop으로 카운트
int count = 0;
for(int i = 0; i < 10000; i++) {
    vector testP = point(1, "P", i);
    if(testP.x == 0 && testP.y == 0 && testP.z == 0) break;
    count = i + 1;
}
```

---

## 최종 작동 코드

### 노드 구조
```
heightfield_file1 (540×900×1 HeightField)
  ↓
heightfield_copylayer1
  - Source: height
  - Destination: spring_dist
  - Copy Source Data: ✓
  ↓
volumewrangle1
  - Input 0: heightfield_copylayer1
  - Input 1: pointwrangle1 (용천수 1025개)
  ↓
heightfield_visualize1 (확인용)
  ↓
heightfield_output1 (spring_distance.exr)

Volume Wrangle 코드

if (@primnum == 2) {
    float total = 0.0;
    float radius = 20.0;  // 영향 반경 (m)
    
    // npoints(1) 대신 직접 1025 사용
    for(int i = 0; i < 1025; i++) {
        vector sp = point(1, "P", i);
        
        // XZ 평면 거리만 계산 (Y 무시)
        float dx = @P.x - sp.x;
        float dz = @P.z - sp.z;
        float dist = sqrt(dx*dx + dz*dz);
        
        if (dist < radius) {
            float influence = 1.0 - (dist / radius);
            total += influence;
        }
    }
    
    f@spring_dist = clamp(total, 0.0, 1.0);
}

디버깅 과정에서 발견한 것들

1. HeightField에서 @P는 이미 월드 좌표

// ❌ 불필요
vector worldPos = volumeindextopos(0, @primnum, @P);

// ✅ 직접 사용
float dx = @P.x - sp.x;

2. @primnum으로 레이어 구분

@primnum == 0: height
@primnum == 1: mask
@primnum == 2: spring_dist

3. Y축 차이 문제

복셀 Y: -1078 (volumeindextopos 사용 시)
용천수 Y: 0.03
해결: XZ 평면 거리만 계산 (2D)

4. 해상도 확인 중요

정상: 540 × 900 × 1
비정상: 540 × 1 (망가진 상태)
i@resx, i@resz로 확인

주요 실수들

❌ 틀린 접근

// pcfind는 Y값도 고려해서 실패
int nearSprings[] = pcfind(1, "P", worldPos, 100.0, 10);

// npoints()가 작동 안 함
int npts = npoints(1);

// volumeindextopos()가 이상한 Y 반환
vector worldPos = volumeindextopos(0, @primnum, @P);

✅ 올바른 접근

// 직접 loop
for(int i = 0; i < 1025; i++)

// @P 직접 사용
float dx = @P.x - sp.x;

// XZ만 계산
float dist = sqrt(dx*dx + dz*dz);

결과

Min/Max: 0.0 ~ 1.0
빨강: 용천수 20m 근처 (영향 강함)
흰색: 용천수 없는 지역 (한라산 중심부)
바다: mask로 제외됨

교훈

Volume Wrangle의 geometry 함수는 제한적 - 특히 두 번째 입력
디버깅 = 작은 단계로 - setdetailattrib으로 중간값 확인
HeightField @P는 월드 좌표 - 변환 불필요
2D 거리로 충분 - Y축 무시
함수 안 되면 직접 구현 - npoints() 대신 loop

Unity VFX _ 2022.3 : 시작점에서 끝점 이동 + 인터렉션(플레이어)

잉_민 — Sun, 7 Dec 2025 06:23:41 +0900

준비 1. visual Effects ( 유니티 프리퍼런스, 셋팅에 있음)

커스텀 노트 만들 수 있어야함. ( 선택, 꼭 필요하지 않을수도..)

준비 2. json 파일. 시작점 끝점 정보를 가진 데이터파일

이부분이 중요함. vfx 그래프에서 이부분을 가져다 씀. simplepathdate*

{
  "paths": [
    {
      "startPos": { "x": -205.804, "y": 6.231, "z": 120.434 },
      "endPos": { "x": -268.549, "y": 5.314, "z": 148.032 },
      "uncertainty": 0.0,
      "victimAge": 28
    },
    {
      "startPos": { "x": -305.804, "y": 6.231, "z": 120.434 },
      "endPos": { "x": -28.017, "y": 6.467, "z": 129.938 },
      "uncertainty": 0.0,
      "victimAge": 0
    }
  ]
}

준비 3. 스크립트 : json을 불러와서 파싱하고 >>> vfx 로 값 보낼수있음.

**여기서 중요한건 데이터 구조를 만드는건데

using UnityEngine;
using UnityEngine.VFX;
using System.Collections.Generic;

// ===== VFX Graph용 구조체 =====
[System.Serializable]
[VFXType(VFXTypeAttribute.Usage.GraphicsBuffer)]  // ← 이것도
public struct SimplePathData
{
    public Vector3 startPos;
    public Vector3 endPos;
    public float uncertainty;
    public uint victimAge;
    //public float sizeMultiplier;
}

// ===== JSON 파싱용 클래스들 =====
[System.Serializable]
public class Vector3Data
{
    public float x, y, z;
    public Vector3 ToVector3() => new Vector3(x, y, z);
}

[System.Serializable]
public class PathEntry
{
    public Vector3Data startPos;
    public Vector3Data endPos;
    public float uncertainty;
    public uint victimAge;
}

[System.Serializable]
public class PathDataWrapper
{
    public List<PathEntry> paths;
}

// ===== 메인 스크립트 =====
public class SimplePathTest : MonoBehaviour
{
    [Header("VFX")]
    public VisualEffect vfxGraph;
    
    [Header("Test Data")]
    public TextAsset jsonFile;
    
    [Header("Player")]
    public Transform player;
    public float detectionRadius = 50f;
    public float enlargeSize = 5f;
    
    private GraphicsBuffer pathBuffer;
    private int pathCount = 0;
    private SimplePathData[] pathDataArray;

    void Start()
    {
        LoadTestData();
    }

    void LoadTestData()
    {
        // JSON 파싱
        PathDataWrapper wrapper = JsonUtility.FromJson<PathDataWrapper>(jsonFile.text);
        pathCount = wrapper.paths.Count;
        
        Debug.Log($"[TEST] {pathCount}개 경로 로드됨");
        
        // GraphicsBuffer 생성
        int stride = System.Runtime.InteropServices.Marshal.SizeOf(typeof(SimplePathData));
        pathBuffer = new GraphicsBuffer(
            GraphicsBuffer.Target.Structured,
            pathCount,
            stride
        );
        
        // 데이터 변환 및 저장
        pathDataArray = new SimplePathData[pathCount];
        for (int i = 0; i < pathCount; i++)
        {
            pathDataArray[i] = new SimplePathData
            {
                startPos = wrapper.paths[i].startPos.ToVector3(),
                endPos = wrapper.paths[i].endPos.ToVector3(),
                uncertainty = wrapper.paths[i].uncertainty,
                victimAge = wrapper.paths[i].victimAge,
                //sizeMultiplier = 1.0f
            };
            
            Debug.Log($"[TEST] Path {i}: {pathDataArray[i].startPos} → {pathDataArray[i].endPos}");
        }
        
        // VFX에 전송
        pathBuffer.SetData(pathDataArray);
        vfxGraph.SetGraphicsBuffer("SimplePathBuffer", pathBuffer);
        vfxGraph.SetInt("SimplePathCount", pathCount);
        
        vfxGraph.Reinit();
        vfxGraph.Play();
        
        StartCoroutine(CheckParticles());
    }
    
    void Update()
    {
        // Player 위치만 VFX에 전송
        if (player != null)
        {
            vfxGraph.SetVector3("PlayerPosition", player.position);
            vfxGraph.SetFloat("DetectionRadius", detectionRadius);
            vfxGraph.SetFloat("EnlargeSize", enlargeSize);
        }
        
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Debug.Log($"Alive: {vfxGraph.aliveParticleCount}");
        }
    }
    
    
    System.Collections.IEnumerator CheckParticles()
    {
        yield return new WaitForSeconds(1f);
        Debug.Log($"[TEST] Alive Particles: {vfxGraph.aliveParticleCount}");
    }

    void OnDestroy()
    {
        if (pathBuffer != null)
        {
            pathBuffer.Release();
            pathBuffer = null;
        }
    }
    
    void OnDrawGizmos()
    {
        if (pathDataArray != null && pathDataArray.Length > 0)
        {
            for (int i = 0; i < pathDataArray.Length; i++)
            {
                // 시작점 (빨강)
                Gizmos.color = Color.red;
                Gizmos.DrawSphere(pathDataArray[i].startPos, 5f);
                
                // 끝점 (파랑)
                Gizmos.color = Color.blue;
                Gizmos.DrawSphere(pathDataArray[i].endPos, 5f);
                
                // 연결선
                Gizmos.color = Color.yellow;
                Gizmos.DrawLine(pathDataArray[i].startPos, pathDataArray[i].endPos);
                
                // 감지 범위
                if (player != null)
                {
                    float distance = Vector3.Distance(player.position, pathDataArray[i].startPos);
                    if (distance < detectionRadius)
                    {
                        Gizmos.color = new Color(1, 1, 0, 0.3f);
                        Gizmos.DrawSphere(pathDataArray[i].startPos, 10f);
                    }
                }
            }
        }
        
        // 플레이어 감지 범위
        if (player != null)
        {
            Gizmos.color = new Color(0, 1, 0, 0.2f);
            Gizmos.DrawWireSphere(player.position, detectionRadius);
        }
    }
}

준비 4 : VFX 그래프에서 ***grapicsbuffer 이거를 만들어줘야함.

이름에 주의하자 ! 값을 받아올때 이름이 같아야 받아와짐.

준비 5. VFX Property Binder

이름 설정할수 있음 SSSPosition 이라고 티나게 바까봄.

아까 위에있는 변수랑 이름일치가 중요.

준비 6. VFX 그래프 만들자

1. 여러번 spawn 되게하기

peridic Burst

2. Count는 선(path) 두개.

delay는 0.2초간격으로.

3. 가끔 안보이거나 중심점이상하면 Bounds 박스 확인. capacity는 파티클 총개수. 센터랑 size 크게 잘맞춰야 보임.

4. 파티클 아이디 get

이게 중요한데 발생하는 파티클에 번호가 붙어있다. 이거를 패스 개수로 나누면. *버퍼인덱스를 얻을 수 있다.

파티클을 계속 발생하니까, 2개의 선이 있으니까.. 몰라 그렇데

5. *bufferindex는 set custom 노드로 만들어야한다. 이름과 변수 성격 uint 를 잘 설정해줘야한다.( 인스펙터창에 있음)

버퍼인덱스를 먼저 설정해주고

6.get bufferindex 할수있다. 왜냐면 set을 위에서 해줬으니까.

이것도 get custom node다. 변수명을 갖게 잘 설정하면, 데이터를 저장하고 다시 받아올수 있는 구조다. 편함.

7. SimplePathBuffer도 우리가 만든 변수다. 밖에서ㄱ 연결할수있게 블랙보드에 만들었던것. ( 코드랑 연결되어있어서 값이 자동으로 들어옴)

8 그래픽 버퍼의 톱니바퀴누르면 우리가 아까 코드에 작성했던 데이터 구조 이름.

데이터 구조에 설정해놓은 시작점 끝점 가져올수있다.

9. 이거를 커스텀 노드에 저장한다. set customnode

이름 설정 주의 .

그러면 아까 말했듯 가져다 쓸수있다.

set position : 초기 시작점

set target position : 이동할점.

초기값 설정은 끝

10 . 업데이트에서 점을 이동시키자

러프를 쓰면됨. (a에서 b로 s동안 이동)

라이프 타임동안 첫점과 끝점을 이동한다.

11. 인터렉션을 위한 장치.

SSSPosition에서 플레이어 위치를 불러와서

각 선의 첫 점과 거리를 비교하여.

특정 거리 내에 있으면 ( detectionRadius) 파티클의 크기를 키운다.

(VFX binder에서 플레이어의 포지션과 연결해주고 변수명을 갖게 설정했기때문에 작동한다) : 위의 단계에서 했던것

12. 마지막으로 아웃풋 어떻게 보일지 설정해주면 끝

----

다음 단계에서는 포물선만들기. 혹은 후디니에서 효과추가하기

houdini to unity 좌표값 보내기

잉_민 — Mon, 1 Dec 2025 20:41:21 +0900

**curve_u = 선을 따라 진행된 비율 (0~1)** ``` 출생지 ─────────────────────> 사망지 0.0 0.25 0.5 0.75 1.0

CSV 파일 구조 확인

row[0] = ID (고유 ID)
row[1] = Name (이름)
row[2] = birth_lat (출생지 위도)
row[3] = birth_lon (출생지 경도)
row[4] = death_lat (사망지 위도)
row[5] = death_lon (사망지 경도)
row[6] = uncertainty_birth (출생지 불확실성)
row[7] = uncertainty_death (사망지 불확실성)
row[8] = Date_Int (사망날짜)

Primitive 속성 (선에 저장):

- path_id (string): 고유 ID ⭐ - person_name (string): 이름 ⭐ - death_date (int): 사망날짜 ⭐

- `time`: 선을 따라 진행된 비율 (0.0 → 1.0) - 애니메이션용 - curve_u와 같은 값

- `death_date`: 실제 사망날짜 (예: 19500315) - 그룹핑/필터링용 - Unity에서 중요!

값매피

path_id = row[0]              # 고유 ID
                person_name = row[1]          # 이름
                birth_lat = float(row[2])     # 출생지 위도
                birth_lon = float(row[3])     # 출생지 경도
                death_lat = float(row[4])     # 사망지 위도
                death_lon = float(row[5])     # 사망지 경도
                uncert_birth = float(row[6])  # 출생지 불확실성
                uncert_death = float(row[7])  # 사망지 불확실성
                death_date = int(row[8])      # 사망날짜

프리미티브에저장

poly.setAttribValue("path_id", path_id)              # 고유 ID
                poly.setAttribValue("person_name", person_name)      # 이름
                poly.setAttribValue("death_date", death_date)        # 사망날짜

                # 좌표 데이터
                poly.setAttribValue("birth_lat", birth_lat)
                poly.setAttribValue("birth_lon", birth_lon)
                poly.setAttribValue("death_lat", death_lat)
                poly.setAttribValue("death_lon", death_lon)

                # 그룹핑용 ID
                poly.setAttribValue("death_grid_id", death_grid)

1. 속도값과 pscale의 의미

pscale (Point Scale)

의미: 포인트의 크기를 제어하는 속성
현재 코드: uncertainty * PSCALE_MULTIPLIER로 설정
목적: 위치 데이터의 불확실성을 시각적으로 표현 (불확실성이 클수록 포인트가 큼)
출생지/사망지 각각의 불확실성을 구분하여 표시

import hou
import csv
import os
import math

# =========================================================================
# 설정
# =========================================================================
# CSV 파일 경로
FILE_PATH = "/Users/l.smin/Documents/4_3_jeju/pj_code/1129/processed_paths.csv"

# 제주도 중심 좌표 (원점)
CENTER_LON = 126.53
CENTER_LAT = 33.50

# 위경도 → 거리 변환
LAT_KM_PER_DEGREE = 111.0  # 위도 1도 ≈ 111km
LON_KM_PER_DEGREE = 111.0 * math.cos(math.radians(CENTER_LAT))  # ≈ 92.4km

# Houdini 공간 스케일 (제주도 동서 73km → 10 units)
SCALE_FACTOR = 10.0 / 73.0  # 1km = 0.137 units

# pscale 배율 (시각화용)
PSCALE_MULTIPLIER = 0.01

# =========================================================================
# Houdini 초기화
# =========================================================================
node = hou.pwd()
geo = node.geometry()
geo.clear()

# -------------------------------------------------------------------------
# 속성 정의
# -------------------------------------------------------------------------
# Point 속성 (점에 저장)
geo.addAttrib(hou.attribType.Point, "pscale", 0.0)           # 점 크기 (시각화)
geo.addAttrib(hou.attribType.Point, "curve_u", 0.0)          # 선 진행 비율 (0→1)
geo.addAttrib(hou.attribType.Point, "uncertainty", 0.0)      # 불확실성 원본값

# Primitive 속성 (선에 저장 - 각 경로의 메타데이터)
geo.addAttrib(hou.attribType.Prim, "path_id", "")            # 고유 ID ⭐
geo.addAttrib(hou.attribType.Prim, "person_name", "")        # 이름 ⭐
geo.addAttrib(hou.attribType.Prim, "death_date", 0)          # 사망날짜 ⭐

# 좌표 데이터 (그룹핑/필터링용)
geo.addAttrib(hou.attribType.Prim, "birth_lat", 0.0)
geo.addAttrib(hou.attribType.Prim, "birth_lon", 0.0)
geo.addAttrib(hou.attribType.Prim, "death_lat", 0.0)
geo.addAttrib(hou.attribType.Prim, "death_lon", 0.0)

# 사망지 그리드 ID (같은 지역 그룹핑용)
geo.addAttrib(hou.attribType.Prim, "death_grid_id", "")

# -------------------------------------------------------------------------
# 좌표 변환 함수
# -------------------------------------------------------------------------
def latlon_to_xy(lat, lon):
    """
    위경도를 Houdini XZ 좌표로 변환
    - 제주도 중심을 (0, 0)으로
    - 실제 거리 비율 유지
    """
    delta_lon = lon - CENTER_LON
    delta_lat = lat - CENTER_LAT
    
    # km 단위 거리
    x_km = delta_lon * LON_KM_PER_DEGREE
    z_km = delta_lat * LAT_KM_PER_DEGREE
    
    # Houdini 좌표 (Z축 반전으로 북쪽=위)
    x = x_km * SCALE_FACTOR
    z = -z_km * SCALE_FACTOR
    
    return (x, z)

def create_death_grid_id(lat, lon, grid_size=0.01):
    """
    사망지를 그리드로 분할해서 ID 생성
    grid_size=0.01 → 약 1km 단위 그리드
    grid_size=0.1 → 약 10km 단위 그리드
    """
    precision = int(1.0 / grid_size)
    grid_lat = int(lat * precision)
    grid_lon = int(lon * precision)
    return f"{grid_lat}_{grid_lon}"

# -------------------------------------------------------------------------
# CSV 파일 읽기 및 경로 생성
# -------------------------------------------------------------------------
if not os.path.exists(FILE_PATH):
    print(f"❌ 파일을 찾을 수 없습니다: {FILE_PATH}")
    print("   경로를 확인해주세요!")
else:
    with open(FILE_PATH, 'r', encoding='utf-8-sig') as f:
        reader = csv.reader(f)
        header = next(reader, None)  # 헤더 스킵

        count = 0
        skipped = 0
        
        for row in reader:
            # 데이터 유효성 검사
            if not row or len(row) < 9:
                skipped += 1
                continue

            try:
                # CSV 데이터 파싱
                path_id = row[0]              # 고유 ID
                person_name = row[1]          # 이름
                birth_lat = float(row[2])     # 출생지 위도
                birth_lon = float(row[3])     # 출생지 경도
                death_lat = float(row[4])     # 사망지 위도
                death_lon = float(row[5])     # 사망지 경도
                uncert_birth = float(row[6])  # 출생지 불확실성
                uncert_death = float(row[7])  # 사망지 불확실성
                death_date = int(row[8])      # 사망날짜
                
                # 유효성 검사: 사망지 좌표가 없는 경우 스킵
                if death_lat == 0.0 and death_lon == 0.0:
                    skipped += 1
                    continue
                
                # 좌표 변환
                birth_x, birth_z = latlon_to_xy(birth_lat, birth_lon)
                death_x, death_z = latlon_to_xy(death_lat, death_lon)
                
                # 사망지 그리드 ID 생성
                death_grid = create_death_grid_id(death_lat, death_lon, grid_size=0.01)

                # =============================================================
                # 지오메트리 생성: 선 (Polygon)
                # =============================================================
                poly = geo.createPolygon()
                poly.setIsClosed(False)  # 열린 선

                # 시작점: 출생지
                pt_birth = geo.createPoint()
                pt_birth.setPosition((birth_x, 0.0, birth_z))
                pt_birth.setAttribValue("curve_u", 0.0)
                pt_birth.setAttribValue("pscale", uncert_birth * PSCALE_MULTIPLIER)
                pt_birth.setAttribValue("uncertainty", uncert_birth)
                poly.addVertex(pt_birth)

                # 끝점: 사망지
                pt_death = geo.createPoint()
                pt_death.setPosition((death_x, 0.0, death_z))
                pt_death.setAttribValue("curve_u", 1.0)
                pt_death.setAttribValue("pscale", uncert_death * PSCALE_MULTIPLIER)
                pt_death.setAttribValue("uncertainty", uncert_death)
                poly.addVertex(pt_death)

                # =============================================================
                # Primitive 속성 설정 (선의 메타데이터)
                # =============================================================
                poly.setAttribValue("path_id", path_id)              # 고유 ID
                poly.setAttribValue("person_name", person_name)      # 이름
                poly.setAttribValue("death_date", death_date)        # 사망날짜
                
                # 좌표 데이터
                poly.setAttribValue("birth_lat", birth_lat)
                poly.setAttribValue("birth_lon", birth_lon)
                poly.setAttribValue("death_lat", death_lat)
                poly.setAttribValue("death_lon", death_lon)
                
                # 그룹핑용 ID
                poly.setAttribValue("death_grid_id", death_grid)
                
                count += 1
                
            except (ValueError, IndexError) as e:
                print(f"⚠️ 데이터 오류 - ID: {row[0] if row else '?'}, 이름: {row[1] if len(row) > 1 else '?'}")
                print(f"   사유: {e}")
                skipped += 1
                continue

        # 완료 메시지
        print("=" * 60)
        print(f"✅ 경로 생성 완료!")
        print(f"   생성: {count}개")
        print(f"   스킵: {skipped}개")
        print(f"   총계: {count + skipped}개")
        print("=" * 60)
        print(f"  스케일: 1km = {SCALE_FACTOR:.3f} Houdini units")
        print(f"  제주도 크기: 동서 {73 * SCALE_FACTOR:.1f} units, 남북 {31 * SCALE_FACTOR:.1f} units")
        print("=" * 60)

============================================================
Houdini 노드 체인 - 완전한 워크플로우
============================================================

1. Python 노드 (위의 코드)
   ↓
   [출력] 400개 선 (Polygons)
   Primitive 속성: path_id, person_name, death_date, death_grid_id, 좌표들
   Point 속성: P, pscale, curve_u, uncertainty

============================================================

2. Resample SOP
   ↓
   설정:
   - Resample: Length
   - Length: 0.2 (또는 0.1 - 점을 촘촘하게)
   - Treat Polygons As: Subdivision Curves

   [출력] 선마다 여러 점이 생김
   - Point 속성 자동 보간 (pscale, curve_u, uncertainty)
   - Primitive 속성 유지 (path_id, person_name, death_date)

============================================================

3. PolyFrame SOP
   ↓
   설정:
   - Entity: Points
   - Style: First Edge
   - Tangent Name: v

   [출력] 각 점에 속도(v) 추가됨
   Point 속성 추가: v (vector)

============================================================

4. Attribute Wrangle SOP (Point 모드) ⭐ 중요!
   ↓
   VEX 코드:

// Primitive 속성 → Point 속성으로 복사
s@path_id = prim(0, "path_id", @primnum);        // 사람 고유 ID
s@person_name = prim(0, "person_name", @primnum); // 이름
i@death_date = prim(0, "death_date", @primnum);   // 사망날짜 (정수)

// 좌표 데이터 (원본 위경도 저장용)
f@birth_lat = prim(0, "birth_lat", @primnum);
f@birth_lon = prim(0, "birth_lon", @primnum);
f@death_lat = prim(0, "death_lat", @primnum);
f@death_lon = prim(0, "death_lon", @primnum);

// 그리드 ID (사망 위치 클러스터링용)
s@death_grid_id = prim(0, "death_grid_id", @primnum);

// 애니메이션용 time 속성
f@time = f@curve_u;  // 0~1 범위

// 날짜 기반 색상 (1947~1958 범위를 0~1로 정규화)
float normalized_date = fit(i@death_date, 19470101, 19561201, 0, 1);
v@Cd = chramp("date_color", normalized_date);  // Ramp 파라미터 필요

   [출력] 모든 속성이 Point에 있음!
   Point 속성: P, v, path_id, person_name, death_date, death_grid_id,
               time, curve_u, uncertainty, pscale, 좌표들

============================================================

5. Delete SOP
   ↓
   설정:
   - Entity: Primitives

delete non select
   - Keep Points: ✅ 체크!

   [출력] Point만 남음 (선은 삭제됨)
   - 모든 속성은 Point에 보존됨

============================================================

6. Labs Niagara ROP (또는 ROP Alembic Output)
   ↓
   Labs Niagara ROP 설정:

   Output Path:
   $HOME/Desktop/migration_paths.hcsv

   Keep Attributes:
   P v path_id person_name death_date death_grid_id time pscale uncertainty

   Cast Attributes:
   0 (필요없음)

   ─────────────────────────────

여기서 실패

Labs Niagara ROP 대신:

File SOP 추가 (Delete 뒤에)
File → $HIP/test.bgeo
File Mode → Write
Save to Disk 클릭

.bgeo 파일이 생성되고 데이터가 있나요? ㅇㅇ

있으면 → Labs Niagara ROP 버그 없으면 → 노드 체인 문제

Labs Niagara ROP 버그

1. bgeo를 JSON으로 변환

delete 다음 - File 연결 뒤에 Python SOP 추가:

import json

node = hou.pwd()
geo = node.geometry()

# Point 데이터 추출
data = []
for pt in geo.points():
    data.append({
        "P": list(pt.position()),
        "v": list(pt.attribValue("v")),
        "path_id": pt.attribValue("path_id"),
        "person_name": pt.attribValue("person_name"),
        "death_date": pt.attribValue("death_date"),
        "death_grid_id": pt.attribValue("death_grid_id"),
        "time": pt.attribValue("time"),
        "pscale": pt.attribValue("pscale"),
        "uncertainty": pt.attribValue("uncertainty")
    })

# JSON 저장
output_path = hou.expandString("$HIP/migration_data.json")
with open(output_path, 'w', encoding='utf-8') as f:
    json.dump(data, f, indent=2)

print(f"✅ JSON 저장 완료: {output_path}")
print(f"  포인트 개수: {len(data)}")

============================================================

최종 출력 데이터 구조:
============================================================

각 Point마다:
- P (vector): 위치
- v (vector): 속도/방향
- path_id (string): 고유 ID
- person_name (string): 이름
- death_date (int): 사망날짜 (YYYYMMDD)
- death_grid_id (string): 사망지 그리드
- time (float): 선 진행 비율 (0~1)
- pscale (float): 점 크기
- uncertainty (float): 불확실성

============================================================
Unity에서 사용:
============================================================

VFX Graph에서 사용하는 방법:

1️⃣ JSON → Texture로 변환 필요

VFX Graph는 JSON을 직접 못 읽습니다. Texture2D 또는 GraphicsBuffer로 변환해야 합니다.

2️⃣ Unity C# 스크립트로 데이터 로드

using UnityEngine;
using System.Collections.Generic;

[System.Serializable]
public class ParticleData
{
    public float[] P;      // Position [x,y,z]
    public float[] v;      // Velocity [x,y,z]
    public string path_id;
    public string person_name;
    public int death_date;
    public string death_grid_id;
    public float time;
    public float pscale;
    public float uncertainty;
}

public class MigrationDataLoader : MonoBehaviour
{
    public TextAsset jsonFile;
    public List<ParticleData> particles;
    
    void Start()
    {
        // JSON 파싱
        particles = JsonUtility.FromJson<List<ParticleData>>(
            "{\"items\":" + jsonFile.text + "}"
        ).items;
        
        Debug.Log($"로드 완료: {particles.Count}개 파티클");
    }
}

3️⃣ VFX Graph 사용 방법

Graphics Buffer 사용

Compute Shader로 데이터 전달
더 복잡하지만 성능 좋음

Houdini to Unity : 벡터 필드(Vector Field)/SDF(Signed Distance Field)

잉_민 — Mon, 1 Dec 2025 00:15:49 +0900

케이지로(Keijiro Takahashi) 방식 "벡터 필드(Vector Field)" 또는 **"SDF(Signed Distance Field) 기반의 흐름 제어"**.

**"파티클의 위치(Position)를 굽는 것(Alembic)"**이 아니라,

"공간에 흐르는 바람의 방향(Velocity/Force)을 굽는 것"**

이 방식이 유니티 VFX Graph에서 훨씬 더 가볍고, 수백만 개의 파티클을 돌려도 렉이 안 걸리며, 무한 루프를 만들기에 가장 좋다.

케이지로 스타일: [Vector Field] vs [SDF] 차이점

Vector Field (벡터 필드): 공간에 **"화살표(방향)"**를 채워 넣는 겁니다. 파티클이 이 공간에 들어오면 화살표 방향대로 떠내려갑니다. (강물, 바람)
SDF (거리 필드): 공간에 **"가장 가까운 표면까지의 거리"**를 저장합니다. 파티클을 선이나 벽에 달라붙게(Attraction) 하거나 밀어낼 때(Collision) 씁니다.

"선을 따라 흐르는 빛의 꼬리"는 보통 이 두 가지를 섞어서 씁니다.

SDF: 파티클이 선 밖으로 도망가지 못하게 잡아당김 (Conform to SDF).
Vector Field: 파티클을 선 방향으로 계속 이동시킴 (Add Force).

후디니에서 [벡터 필드] 만들어서 유니티로 보내는 법

Alembic 대신 **Volume Texture (3D Texture)**를 구워서 유니티로 보내야 합니다.

이 과정은 SideFX Labs 툴을 쓰면 아주 쉽습니다.

1단계: 선(Curve)에 흐름(Velocity) 만들기

기존에 만든 선(GUIDE_PATH)을 그대로 씁니다.

선만들기

import hou
import csv
import os
import math

# =========================================================================
# [설정 1] CSV 파일 경로
file_path = "/Users/l.smin/Documents/4_3_jeju/pj_code/1129/processed_paths.csv"

# [설정 2] 제주도 기준값 (원점 정렬용)
CENTER_LON = 126.53
CENTER_LAT = 33.50

# [설정 3] 실제 거리 변환 계산
# 제주도 위도(33.5도)에서의 1도당 거리 (km)
LAT_KM_PER_DEGREE = 111.0  # 위도 1도 ≈ 111km (지구 어디서나 거의 일정)
LON_KM_PER_DEGREE = 111.0 * math.cos(math.radians(CENTER_LAT))  # ≈ 92.4km

# [설정 4] 후디니 공간 스케일 (km -> Houdini units)
# 제주도 동서 약 73km, 남북 약 31km
# 후디니에서 10 units 정도 크기로 맞추려면:
SCALE_FACTOR = 10.0 / 73.0  # 1km = 0.137 units 정도

# [설정 5] pscale 조정값 (불확실성 시각화)
PSCALE_MULTIPLIER = 0.01  # 필요시 조정
# =========================================================================

node = hou.pwd()
geo = node.geometry()
geo.clear() 

# -------------------------------------------------------------------------
# 1. 속성 생성
# -------------------------------------------------------------------------
geo.addAttrib(hou.attribType.Point, "pscale", 0.0)       
geo.addAttrib(hou.attribType.Point, "curve_u", 0.0)      
geo.addAttrib(hou.attribType.Prim, "ID", "")             
geo.addAttrib(hou.attribType.Prim, "Name", "")           
geo.addAttrib(hou.attribType.Prim, "Date_Int", 0)        
geo.addAttrib(hou.attribType.Prim, "place_of_death", "")
geo.addAttrib(hou.attribType.Point, "uncertainty", 0.0)  # 원본 불확실성 저장

# -------------------------------------------------------------------------
# 2. 좌표 변환 함수
# -------------------------------------------------------------------------
def latlon_to_xy(lat, lon):
    """
    위경도를 후디니 XZ 좌표로 변환
    - 실제 거리 비율을 유지
    - 제주도 중심을 (0, 0)으로
    """
    # 1. 위경도 차이 계산
    delta_lon = lon - CENTER_LON
    delta_lat = lat - CENTER_LAT
    
    # 2. 실제 거리(km)로 변환
    x_km = delta_lon * LON_KM_PER_DEGREE
    z_km = delta_lat * LAT_KM_PER_DEGREE
    
    # 3. 후디니 좌표로 스케일 (Z축 반전으로 북쪽=위 맞춤)
    x = x_km * SCALE_FACTOR
    z = -z_km * SCALE_FACTOR  # 음수로 지도 방향 맞춤
    
    return (x, z)

# -------------------------------------------------------------------------
# 3. 파일 읽기 및 생성
# -------------------------------------------------------------------------
if not os.path.exists(file_path):
    print("❌ 파일 경로 에러: 파일을 찾을 수 없습니다 -> " + file_path)
else:
    with open(file_path, 'r', encoding='utf-8-sig') as f:
        reader = csv.reader(f)
        header = next(reader, None) 

        count = 0
        skipped = 0
        
        for row in reader:
            if not row or len(row) < 9: 
                continue

            try:
                # 데이터 파싱
                s_lat = float(row[2])
                s_lon = float(row[3]) 
                e_lat = float(row[4])
                e_lon = float(row[5])
                
                # 유효성 검사
                if e_lat == 0.0 and e_lon == 0.0: 
                    skipped += 1
                    continue
                
                uncert_origin = float(row[6])
                uncert_death = float(row[7])
                date_val = int(row[8])

                # -------------------------------------------------
                # [좌표 변환] 실제 거리 비율 유지
                # -------------------------------------------------
                x1, z1 = latlon_to_xy(s_lat, s_lon)
                x2, z2 = latlon_to_xy(e_lat, e_lon)

                # -------------------------------------------------
                # [지오메트리 생성]
                # -------------------------------------------------
                poly = geo.createPolygon()
                poly.setIsClosed(False)

                # 시작점 (출생지)
                pt1 = geo.createPoint()
                pt1.setPosition((x1, 0.0, z1))  # Y=0으로 지면에 배치
                pt1.setAttribValue("curve_u", 0.0)
                pt1.setAttribValue("pscale", uncert_origin * PSCALE_MULTIPLIER)
                pt1.setAttribValue("uncertainty", uncert_origin)
                poly.addVertex(pt1)

                # 도착점 (사망지)
                pt2 = geo.createPoint()
                pt2.setPosition((x2, 0.0, z2))
                pt2.setAttribValue("curve_u", 1.0)
                pt2.setAttribValue("pscale", uncert_death * PSCALE_MULTIPLIER)
                pt2.setAttribValue("uncertainty", uncert_death)
                poly.addVertex(pt2)

                # 메타데이터 입력
                poly.setAttribValue("ID", row[0])
                poly.setAttribValue("Name", row[1])
                poly.setAttribValue("Date_Int", date_val)
                poly.setAttribValue("place_of_death", row[9] if len(row) > 9 else "")
                
                count += 1
                
            except ValueError as e:
                print(f"⚠️ 데이터 변환 오류: {row[:2]} / 사유: {e}")
                skipped += 1
                continue

        print(f"✅ 성공: {count}개 경로 생성 완료")
        print(f"  통계: 스킵됨 {skipped}개")
        print(f"  스케일: 1km = {SCALE_FACTOR:.3f} units")
        print(f"  비율: Lon={LON_KM_PER_DEGREE:.1f}km/deg, Lat={LAT_KM_PER_DEGREE:.1f}km/deg")

1단계: 선 만들기 (Python Node)

파이썬(위의 코드)으로 두점 연결하기 + Resample

Resample 세팅:

Resample: Length
Length: 0.5 (선을 매끄럽게)

2단계: 제주도 지형에 붙이기 (Ray)

[Resample] → Ray

Ray 노드:

Ray from: First Input (선)
Ray onto: Second Input (제주도 FBX 연결)
Direction: Y축 (0, -1, 0)
Maximum Ray Distance: 100
Lift Amount: 0.1 (지면에서 살짝 띄우기)

제주 FBX 준비:

File SOP으로 불러오기
Transform으로 크기/위치 맞추기 (Python 노드 결과와 겹치게)

3단계: 속도(v) 만들기 (PolyFrame)

[Ray] → PolyFrame

PolyFrame 세팅:

Entity: Points
Style: First Edge
Tangent Name: v

이제 선에 화살표 방향이 생깁니다!

PolyFrame 노드: Resample 아래에 답니다.
- Style: First Edge
- Tangent Name: v (접선 방향을 속도 v로 변환)
- 이러면 선을 따라가는 화살표가 생깁니다.

2단계: 볼륨(Volume)으로 변환

선은 얇아서 유니티가 감지를 못 합니다. 선 주변을 감싸는 두툼한 안개(Volume)로 만들어야 합니다.

vdb from particles

4단계: trail

result type : compute velocity

attribute match : v

5단계: 볼륨으로 변환 (Vdb from oartucke

빨강/파랑 구름이 보이면 성공!

6단계: 유니티용 3D 텍스처로 굽기

방법 A: Labs 툴 (쉬움)

[Volume] → Labs Volume Texture 3D

1. Mode

Mode: Density → Vector Field 로 변경!

중요! 벡터 데이터를 굽는 거라 커스텀 Vector Field : v

2. Resolution

Slices: 64 → 128 (더 고품질)
Resolution per Slice: 256 → 128

또는 테스트용:
Slices: 64
Resolution per Slice: 64

최종 해상도:

64 x 64 x 64 = 테스트용 (가벼움)
128 x 128 x 128 = 추천 (균형)
256 x 256 x 256 = 최고품질 (무거움)

3. 출력 파일

스크롤 내려서:

Output Picture: 
$HIP/vectorfield.exr

최종 세팅:

Mode: Vector Field ← 필수!
Up Axis: Z
Slices: 128
Resolution per Slice: 128
Clipping Ratio: 1
Output: $HIP/vectorfield.exr

Render 버튼 누르면 끝!

약 2-3분 걸립니다 (128³ 기준).

유니티에서 쓰기

VFX Graph에서:

3D Texture 임포트
Texture 3D 타입으로 설정
Particle 노드에 Sample Vector Field 연결

이제 유니티로 와서 .exr 혹은 .asset으로 된 3D Texture가 생겼을 겁니다.

VFX Graph를 켭니다.
Initialize 단계:
- 파티클을 선 근처 위치에 생성하거나, 박스 형태로 넉넉하게 뿌립니다.
Update 단계 (핵심):
- Sample Texture 3D 노드 생성.
- 여기에 후디니에서 가져온 텍스처를 넣습니다.
- UVW 좌표: Get Attribute: Position 노드를 연결해서, 파티클의 현재 위치가 텍스처의 어느 부분인지 알려줍니다. (좌표 스케일 조정 필요할 수 있음)
- 출력값(RGB) → Set Velocity 또는 Add Force 노드에 연결.