๐จ ์์์ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ์ ํจ์๋ก ํํํ๊ธฐ
์๋ , ์น๊ตฌ๋ค! ์ค๋์ ์ ๋ง ์ฌ๋ฏธ์๊ณ ํฅ๋ฏธ์ง์งํ ์ฃผ์ ๋ฅผ ๊ฐ์ง๊ณ ์์ด. ๋ฐ๋ก ์์์ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ์ ํจ์๋ก ์ด๋ป๊ฒ ํํํ ์ ์๋์ง์ ๋ํด ์์๋ณผ ๊ฑฐ์ผ. ์ด๋ ต๊ฒ ๋ค๋ฆด ์๋ ์๊ฒ ์ง๋ง, ๊ฑฑ์ ๋ง! ๋ด๊ฐ ์ฝ๊ณ ์ฌ๋ฏธ์๊ฒ ์ค๋ช ํด์ค๊ฒ. ๐
์ฐ๋ฆฌ๊ฐ ์ผ์์์ ๋ณด๋ ์๋ฆ๋ค์ด ๊ทธ๋ผ๋ฐ์ด์ ๋ค, ์๋ฅผ ๋ค์ด ์์์ ํ๋์ด๋ ๋ฌด์ง๊ฐ ๊ฐ์ ๊ฒ๋ค... ์ด๋ฐ ์์ฐ์ ์๋ฆ๋ค์์ ์ํ์ผ๋ก ํํํ ์ ์๋ค๋, ์ ๋ง ์ ๊ธฐํ์ง ์์? ๐ ๐ ๊ทธ๋ผ ์ด์ ๋ถํฐ ์์์ ์ธ๊ณ์ ์ํ์ ์ธ๊ณ๋ฅผ ์ฐ๊ฒฐํ๋ ํฅ๋ฏธ์ง์งํ ์ฌํ์ ๋ ๋๋ณผ๊น?
๐ ์ฐ๋ฆฌ์ ๋ชฉํ: ์ด ๊ธ์ ๋ค ์ฝ๊ณ ๋๋ฉด, ๋ํฌ๋ ์์ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ์ ์ผ๋ก ์ดํดํ๊ณ ํํํ ์ ์๊ฒ ๋ ๊ฑฐ์ผ. ๋ง์น ์ฌ๋ฅ๋ท์์ ์๋ก์ด ์ฌ๋ฅ์ ๋ฐฐ์ฐ๋ฏ์ด ๋ง์ด์ผ!
์, ๊ทธ๋ผ ์์ํด๋ณผ๊น? ์ฐ๋ฆฌ์ ์ฌ์ ์ ํฌ๊ฒ ๋ค์๊ณผ ๊ฐ์ ์์๋ก ์งํ๋ ๊ฑฐ์ผ:
- ์์์ ๊ธฐ๋ณธ ์ดํดํ๊ธฐ
- ๊ทธ๋ผ๋ฐ์ด์ ์ด๋ ๋ฌด์์ธ๊ฐ?
- ์ํ ํจ์์ ๊ธฐ์ด
- ์์์ ์ํ์ผ๋ก ํํํ๊ธฐ
- ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ ํจ์๋ก ๋ํ๋ด๊ธฐ
- ์ค์ ์์ฉ ์์
์ค๋น๋๋? ๊ทธ๋ผ ์ถ๋ฐ~! ๐
1. ์์์ ๊ธฐ๋ณธ ์ดํดํ๊ธฐ ๐
์์์ ๋ํด ์ด์ผ๊ธฐํ๊ธฐ ์ ์, ์ฐ๋ฆฌ๊ฐ ์์์ ์ด๋ป๊ฒ ์ธ์ํ๋์ง ์์๋ณผ ํ์๊ฐ ์์ด. ์ฐ๋ฆฌ ๋์ ์ ๋ง ์ ๊ธฐํ ๊ธฐ๊ด์ด์ผ. ๋น์ ๋ฐ์๋ค์ด๊ณ , ๊ทธ ์ ๋ณด๋ฅผ ๋๋ก ์ ๋ฌํด์ ์ฐ๋ฆฌ๊ฐ ์ธ์์ ์ปฌ๋ฌํํ๊ฒ ๋ณผ ์ ์๊ฒ ํด์ฃผ์ง.
๐๏ธ ์ฐ๋ฆฌ ๋์ ๊ตฌ์กฐ
์ฐ๋ฆฌ ๋ ์์๋ ๋ง๋ง์ด๋ผ๋ ๋ถ๋ถ์ด ์์ด. ์ด ๋ง๋ง์๋ ๋ ์ข ๋ฅ์ ์ธํฌ๊ฐ ์์ง:
- ๋ง๋์ธํฌ: ๋ฐ๊ธฐ๋ฅผ ๊ฐ์งํด
- ์๋ฟ์ธํฌ: ์์์ ๊ฐ์งํด
ํนํ ์๋ฟ์ธํฌ๊ฐ ์ค์ํ๋ฐ, ์ด ์ธํฌ์๋ ์ธ ๊ฐ์ง ์ข ๋ฅ๊ฐ ์์ด:
- ๐ด ๋นจ๊ฐ์์ ๊ฐ์งํ๋ ์ธํฌ
- ๐ข ์ด๋ก์์ ๊ฐ์งํ๋ ์ธํฌ
- ๐ต ํ๋์์ ๊ฐ์งํ๋ ์ธํฌ
์ด ์ธ ๊ฐ์ง ์์์ ์กฐํฉ์ผ๋ก ์ฐ๋ฆฌ๋ ๋ชจ๋ ์์์ ๋ณผ ์ ์๊ฒ ๋๋ ๊ฑฐ์ผ. ์ ๊ธฐํ์ง?
๐จ RGB ์์ ๋ชจ๋ธ
์ปดํจํฐ๋ ๋์งํธ ๊ธฐ๊ธฐ์์ ์์์ ํํํ ๋๋ ์ฃผ๋ก RGB ์์ ๋ชจ๋ธ์ ์ฌ์ฉํด. RGB๋ Red(๋นจ๊ฐ), Green(์ด๋ก), Blue(ํ๋)์ ์ฝ์์ผ. ์ด ์ธ ๊ฐ์ง ์์์ ์กฐํฉ์ผ๋ก ๋ชจ๋ ์์ ๋ง๋ค ์ ์์ด.
RGB ๋ชจ๋ธ์์๋ ๊ฐ ์์์ ๊ฐ๋๋ฅผ 0๋ถํฐ 255๊น์ง์ ์ซ์๋ก ํํํด. ์๋ฅผ ๋ค์ด:
- RGB(255, 0, 0)์ ์์ํ ๋นจ๊ฐ์
- RGB(0, 255, 0)์ ์์ํ ์ด๋ก์
- RGB(0, 0, 255)์ ์์ํ ํ๋์
- RGB(255, 255, 255)์ ํฐ์
- RGB(0, 0, 0)์ ๊ฒ์ ์
์ด๋ ๊ฒ ์ซ์๋ก ํํํ ์ ์๋ค๋ ์ ์ด ๋ฐ๋ก ์์์ ์ํ์ ์ผ๋ก ๋ค๋ฃฐ ์ ์๊ฒ ํด์ฃผ๋ ํต์ฌ์ด์ผ!
๐ค ์๊ฐํด๋ณด๊ธฐ: RGB ๋ชจ๋ธ์์ ๋ ธ๋์์ ์ด๋ป๊ฒ ํํ๋ ๊น? (ํํธ: ๋นจ๊ฐ๊ณผ ์ด๋ก์ ์์ผ๋ฉด ๋ ธ๋์์ด ๋ผ!)
๐๏ธ HSL ์์ ๋ชจ๋ธ
RGB ์ธ์๋ HSL์ด๋ผ๋ ์์ ๋ชจ๋ธ๋ ์์ด. HSL์ Hue(์์กฐ), Saturation(์ฑ๋), Lightness(๋ช ๋)์ ์ฝ์์ผ. ์ด ๋ชจ๋ธ์ ์ธ๊ฐ์ด ์์์ ์ธ์ํ๋ ๋ฐฉ์์ ๋ ๊ฐ๊น์์, ๋์์ด๋๋ค์ด ์์ฃผ ์ฌ์ฉํด.
- Hue(์์กฐ): 0๋ถํฐ 360๊น์ง์ ๊ฐ๋๋ก ํํ๋ผ. ์๋ฅผ ๋ค์ด, 0ยฐ(๋๋ 360ยฐ)๋ ๋นจ๊ฐ, 120ยฐ๋ ์ด๋ก, 240ยฐ๋ ํ๋์ด์ผ.
- Saturation(์ฑ๋): 0%๋ถํฐ 100%๊น์ง๋ก ํํ๋ผ. 0%๋ ํ์์กฐ, 100%๋ ๊ฐ์ฅ ์ ๋ช ํ ์์์ด์ผ.
- Lightness(๋ช ๋): ์ด๊ฒ๋ 0%๋ถํฐ 100%๊น์ง์ผ. 0%๋ ๊ฒ์ , 100%๋ ํฐ์, 50%๋ '๋ณดํต' ๋ฐ๊ธฐ์ ์์์ด ๋ผ.
์๋ฅผ ๋ค์ด, hsl(0, 100%, 50%)๋ ์์ํ ๋นจ๊ฐ์์ ๋ํ๋ด.
์์ SVG ๊ทธ๋ํฝ์ ๋ณด๋ฉด, ๊ฐ์ ๋นจ๊ฐ์์ RGB์ HSL๋ก ๊ฐ๊ฐ ํํํ ๊ฑธ ๋ณผ ์ ์์ด. ๋ ๋ชจ๋ธ ๋ค ๊ฐ์ ์์์ ๋ํ๋ด์ง๋ง, ํํ ๋ฐฉ์์ด ๋ค๋ฅด์ง?
๐งฎ ์์๊ณผ ์ํ์ ๋ง๋จ
์ฌ๊ธฐ์ ์ค์ํ ์ ์ ๋ชจ๋ ์์์ด ์ซ์๋ก ํํ๋๋ค๋ ๊ฑฐ์ผ. ์ด๊ฒ ๋ฐ๋ก ์์์ ์ํ์ ์ผ๋ก ๋ค๋ฃฐ ์ ์๊ฒ ํด์ฃผ๋ ํต์ฌ์ด์ง! ์๋ฅผ ๋ค์ด, ๋ ์์์ ์๋๋ค๊ณ ์๊ฐํด๋ณด์. ์ํ์ ์ผ๋ก๋ ์ด ๋ ์์์ RGB ๊ฐ๋ค์ ํ๊ท ์ ๊ตฌํ๋ ๊ฑฐ์ผ.
์๋ฅผ ๋ค์ด, ๋นจ๊ฐ์ RGB(255, 0, 0)๊ณผ ํ๋์ RGB(0, 0, 255)๋ฅผ ์์ผ๋ฉด:
R = (255 + 0) / 2 = 127.5
G = (0 + 0) / 2 = 0
B = (0 + 255) / 2 = 127.5
๊ฒฐ๊ณผ๋ RGB(128, 0, 128)์ด ๋๋๋ฐ, ์ด๊ฑด ๋ณด๋ผ์์ด์ผ! (์์์ ์ ๋ฐ์ฌ๋ฆผํ์ด)
์ด๋ ๊ฒ ์์์ ์ซ์๋ก ํํํ๊ณ ๊ณ์ฐํ ์ ์๋ค๋ ์ ์ด ๋ฐ๋ก ์ฐ๋ฆฌ๊ฐ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ์ ํจ์๋ก ํํํ ์ ์๊ฒ ํด์ฃผ๋ ๊ธฐ๋ฐ์ด ๋ผ. ์ฌ๋ฅ๋ท์์ ์๋ก์ด ๊ธฐ์ ์ ๋ฐฐ์ฐ๋ฏ, ์ฐ๋ฆฌ๋ ์ด์ ์์์ ์ํ์ ์ผ๋ก ๋ค๋ฃจ๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ฐ๊ณ ์๋ ๊ฑฐ์ผ!
๐ก ์์๋๋ฉด ์ข์ ์ : ์์์ ์ํ์ ์ผ๋ก ๋ค๋ฃฐ ์ ์๋ค๋ ๊ฑด ์ปดํจํฐ ๊ทธ๋ํฝ, ๋์งํธ ์ํธ, ์น ๋์์ธ ๋ฑ ๋ค์ํ ๋ถ์ผ์์ ๊ต์ฅํ ์ค์ํด. ์ด๋ฐ ์ง์์ ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ๋์์ธ์ด๋ ํ๋ก๊ทธ๋๋ฐ ๊ด๋ จ ์ฌ๋ฅ์ ๊ณต์ ํ ๋ ํฐ ๋์์ด ๋ ์ ์์ด!
์, ์ด์ ์ฐ๋ฆฌ๋ ์์์ ๊ธฐ๋ณธ์ ๋ํด ์์๋ดค์ด. ๋ค์์ผ๋ก๋ ๊ทธ๋ผ๋ฐ์ด์ ์ด ๋ญ์ง, ์ด๋ป๊ฒ ๋ง๋ค์ด์ง๋์ง ์์๋ณผ ๊ฑฐ์ผ. ์ค๋น๋๋? ๊ณ์ ๊ฐ๋ณด์! ๐
2. ๊ทธ๋ผ๋ฐ์ด์ ์ด๋ ๋ฌด์์ธ๊ฐ? ๐
์, ์ด์ ์ฐ๋ฆฌ์ ์ฃผ์ธ๊ณต์ธ '๊ทธ๋ผ๋ฐ์ด์ '์ ๋ํด ์์ธํ ์์๋ณผ ์๊ฐ์ด์ผ. ๊ทธ๋ผ๋ฐ์ด์ ์ด๋ผ๋ ๋ง, ๋ค์ด๋ณธ ์ ์์ง? ๋ญ๊ฐ ๋ฉ์๊ณ ๋ถ๋๋ฝ๊ฒ ์์์ด ๋ณํ๋ ๊ฑธ ๋ ์ฌ๋ ธ๋ค๋ฉด ์ ๋ต์ด์ผ! ๐
๐จ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ ์
๊ทธ๋ผ๋ฐ์ด์ ์ ํ ์์์์ ๋ค๋ฅธ ์์์ผ๋ก ์ ์ง์ ์ผ๋ก ๋ณํํ๋ ๊ฒ์ ๋งํด. ๋ง์น ํด๊ฐ ์ง ๋ ํ๋์ ์์ด ํ๋์์์ ์ฃผํฉ์, ๋นจ๊ฐ์์ผ๋ก ์์ํ ๋ณํ๋ ๊ฒ์ฒ๋ผ ๋ง์ด์ผ. ์์ฐ์์๋, ์ฐ๋ฆฌ๊ฐ ๋ง๋๋ ๋์์ธ์์๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ ๋ง ๋ง์ด ๋ณผ ์ ์์ด.
๐ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ข ๋ฅ
๊ทธ๋ผ๋ฐ์ด์ ์๋ ์ฌ๋ฌ ์ข ๋ฅ๊ฐ ์์ด. ์ฃผ์ํ ๋ช ๊ฐ์ง๋ฅผ ์ดํด๋ณผ๊น?
- ์ ํ ๊ทธ๋ผ๋ฐ์ด์ (Linear Gradient): ์ง์ ์ ๋ฐ๋ผ ์์์ด ๋ณํ๋ ๊ฑฐ์ผ. ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก, ์์์ ์๋๋ก, ๋๋ ๋๊ฐ์ ๋ฐฉํฅ์ผ๋ก ์์์ด ๋ณํ ์ ์์ด.
- ๋ฐฉ์ฌํ ๊ทธ๋ผ๋ฐ์ด์ (Radial Gradient): ์ค์ฌ์ ์์ ๋ฐ๊นฅ์ชฝ์ผ๋ก ์ํ์ผ๋ก ํผ์ง๋ฉด์ ์์์ด ๋ณํด.
- ์๋ฟํ ๊ทธ๋ผ๋ฐ์ด์ (Conic Gradient): ์ค์ฌ์ ์ ๊ธฐ์ค์ผ๋ก ์์ ๊ทธ๋ฆฌ๋ฏ์ด ์์์ด ๋ณํด. ๋ง์น ์์ํ์ฒ๋ผ ๋ณด์ผ ์ ์์ด.
๐ง ๊ทธ๋ผ๋ฐ์ด์ ์ ์ด๋ป๊ฒ ๋ง๋ค์ด์ง๊น?
๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋๋ ๊ธฐ๋ณธ ์๋ฆฌ๋ ๊ฐ๋จํด. ๋ ๊ฐ ์ด์์ ์์์ ์ ํํ๊ณ , ๊ทธ ์ฌ์ด์ ์์๋ค์ ๊ณ์ฐํด๋ด๋ ๊ฑฐ์ผ. ์๋ฅผ ๋ค์ด, ๋นจ๊ฐ์์์ ํ๋์์ผ๋ก ๋ณํ๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ ๋ค๊ณ ์๊ฐํด๋ณด์.
- ์์ ์์: ๋นจ๊ฐ์ (RGB: 255, 0, 0)
- ๋ ์์: ํ๋์ (RGB: 0, 0, 255)
- ์ค๊ฐ ์์๋ค: ์ด ๋ ์์ ์ฌ์ด์ ๋ชจ๋ ์์
์ค๊ฐ ์์๋ค์ ์ด๋ป๊ฒ ๊ณ์ฐ๋ ๊น? ๋ฐ๋ก ์ฌ๊ธฐ์ ์ํ์ด ๋ฑ์ฅํด! ๐งฎ
๐ข ๊ทธ๋ผ๋ฐ์ด์ ๊ณผ ์ํ์ ๊ด๊ณ
๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ๋, ์ฐ๋ฆฌ๋ ์์ ์์์์ ๋ ์์์ผ๋ก ์ ์ง์ ์ผ๋ก ๋ณํํ๋ ๊ฐ๋ค์ ๊ณ์ฐํด์ผ ํด. ์ด๊ฑธ ์ํ์ ์ผ๋ก ํํํ๋ฉด ๋ค์๊ณผ ๊ฐ์:
์ค๊ฐ์์ = ์์์์ + (๋์์ - ์์์์) * t
์ฌ๊ธฐ์ 't'๋ 0์์ 1 ์ฌ์ด์ ๊ฐ์ด์ผ. 0์ผ ๋๋ ์์ ์์, 1์ผ ๋๋ ๋ ์์์ด ๋๊ณ , ๊ทธ ์ฌ์ด์ ๊ฐ๋ค์ ์ค๊ฐ ์์๋ค์ด ๋๋ ๊ฑฐ์ง.
์๋ฅผ ๋ค์ด, ๋นจ๊ฐ์(255, 0, 0)์์ ํ๋์(0, 0, 255)์ผ๋ก ๋ณํ๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ค๊ฐ ์ง์ (t = 0.5)์:
R = 255 + (0 - 255) * 0.5 = 127.5
G = 0 + (0 - 0) * 0.5 = 0
B = 0 + (255 - 0) * 0.5 = 127.5
๊ฒฐ๊ณผ๋ RGB(128, 0, 128)์ด ๋๋๋ฐ, ์ด๊ฑด ๋ณด๋ผ์์ด์ผ! (์์์ ์ ๋ฐ์ฌ๋ฆผํ์ด)
๐ก ์ฌ๋ฅ๋ท ํ: ์ด๋ฐ ๊ทธ๋ผ๋ฐ์ด์ ๊ณ์ฐ ์๋ฆฌ๋ฅผ ์ดํดํ๋ฉด, ๋์งํธ ์ํธ๋ ์น ๋์์ธ์์ ๋์ฑ ์ธ๋ จ๋ ์ํ์ ๋ง๋ค ์ ์์ด. ์ฌ๋ฅ๋ท์์ ๊ทธ๋ํฝ ๋์์ธ์ด๋ ์น ๊ฐ๋ฐ ๊ด๋ จ ์ฌ๋ฅ์ ๊ณต์ ํ๋ค๋ฉด, ์ด๋ฐ ์ง์์ ์ ๋ง ์ ์ฉํ ๊ฑฐ์ผ!
๐๏ธ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ค์ ์์ฉ
๊ทธ๋ผ๋ฐ์ด์ ์ ์ฐ๋ฆฌ ์ผ์ ๊ณณ๊ณณ์์ ๋ณผ ์ ์์ด:
- ๐ฑ ์ค๋งํธํฐ ๋ฐฐ๊ฒฝํ๋ฉด
- ๐ฅ๏ธ ์น์ฌ์ดํธ ๋์์ธ
- ๐จ ๋์งํธ ์ํธ
- ๐ ๋ฐ์ดํฐ ์๊ฐํ
- ๐๏ธ ๊ฑด์ถ๋ฌผ์ ์กฐ๋ช
ํนํ ์น ๋์์ธ์์๋ CSS๋ฅผ ์ฌ์ฉํด ์ฝ๊ฒ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ์ ์์ด. ์๋ฅผ ๋ค์ด:
background: linear-gradient(to right, red, blue);
์ด ์ฝ๋๋ ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ๋นจ๊ฐ์์์ ํ๋์์ผ๋ก ๋ณํ๋ ์ ํ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค์ด๋ด์ง.
๐ค ๊ทธ๋ผ๋ฐ์ด์ ์ ๋งค๋ ฅ
๊ทธ๋ผ๋ฐ์ด์ ์ด ์ด๋ ๊ฒ ๋ง์ด ์ฌ์ฉ๋๋ ์ด์ ๊ฐ ๋ญ๊น?
- ์๊ฐ์ ํฅ๋ฏธ: ๋จ์๋ณด๋ค ๋ ๋์ ์ด๊ณ ํฅ๋ฏธ๋ก์ด ๋๋์ ์ค.
- ๋ถ๋๋ฌ์ด ์ ํ: ๊ธ๊ฒฉํ ์์ ๋ณํ ์์ด ์์ฐ์ค๋ฌ์ด ์ ํ์ ๋ง๋ค์ด๋ด.
- ๊น์ด๊ฐ ํํ: ํ๋ฉด์ ์ธ ๋์์ธ์ ์ ์ฒด๊ฐ์ ๋ํด์ค.
- ๊ฐ์ ์ ๋ฌ: ์์์ ๋ณํ๋ก ๋ค์ํ ๊ฐ์ ์ด๋ ๋ถ์๊ธฐ๋ฅผ ํํํ ์ ์์ด.
- ์ ๋ณด ์ ๋ฌ: ๋ฐ์ดํฐ ์๊ฐํ์์ ์ฐ์์ ์ธ ๊ฐ์ ๋ณํ๋ฅผ ํํํ๋ ๋ฐ ์ ์ฉํด.
์ด๋ ๊ฒ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋จ์ํ ์์ ๊ฒ ์ด์์ ์๋ฏธ๋ฅผ ๊ฐ์ง๊ณ ์์ด. ๊ทธ๋ฆฌ๊ณ ์ด ๋ชจ๋ ๊ฒ์ด ์ํ์ ๊ธฐ๋ฐ์ผ๋ก ํ๊ณ ์๋ค๋, ์ ๋ง ์ ๊ธฐํ์ง ์์? ๐โจ
๐ค ์๊ฐํด๋ณด๊ธฐ: ๋ํฌ๊ฐ ๊ฐ์ฅ ์ข์ํ๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ญ์ผ? ์ด๋ค ์์๋ค๋ก ์ด๋ฃจ์ด์ ธ ์๊ณ , ์ด๋ค ๋๋์ ์ฃผ๋์ง ํ๋ฒ ์๊ฐํด๋ด!
์, ์ด์ ์ฐ๋ฆฌ๋ ๊ทธ๋ผ๋ฐ์ด์ ์ด ๋ญ์ง, ์ด๋ป๊ฒ ๋ง๋ค์ด์ง๋์ง ์๊ฒ ๋์ด. ๋ค์์ผ๋ก๋ ์ด ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ ์ ๊ตํ๊ฒ ํํํ๊ธฐ ์ํด ํ์ํ ์ํ์ ํจ์์ ๋ํด ์์๋ณผ ๊ฑฐ์ผ. ์ค๋น๋๋? ๊ณ์ ๊ฐ๋ณด์! ๐
3. ์ํ ํจ์์ ๊ธฐ์ด ๐
์, ์ด์ ์ฐ๋ฆฌ์ ์ฌ์ ์์ ๊ฐ์ฅ ํฅ๋ฏธ์ง์งํ ๋ถ๋ถ์ ๋๋ฌํ์ด! ๋ฐ๋ก ์ํ ํจ์์ผ. "์ด? ์ํ์ด๋ผ๊ณ ? ์ด๋ ค์ธ ๊ฒ ๊ฐ์๋ฐ..." ๋ผ๊ณ ์๊ฐํ ์๋ ์๊ฒ ์ง๋ง, ๊ฑฑ์ ๋ง! ๋ด๊ฐ ์ฝ๊ณ ์ฌ๋ฏธ์๊ฒ ์ค๋ช ํด์ค๊ฒ. ๐
๐งฎ ํจ์๋ ๋ฌด์์ผ๊น?
ํจ์๋ ๊ฐ๋จํ ๋งํด์ ์ ๋ ฅ๊ฐ์ ๋ฐ์ ์ถ๋ ฅ๊ฐ์ ๋ด๋๋ ๊ด๊ณ์ผ. ๋ง์น ์๋ฆฌ ๋ ์ํผ์ฒ๋ผ ์๊ฐํ๋ฉด ๋ผ. ์ฌ๋ฃ(์ ๋ ฅ๊ฐ)๋ฅผ ๋ฃ์ผ๋ฉด ์๋ฆฌ(์ถ๋ ฅ๊ฐ)๊ฐ ๋์ค๋ ๊ฑฐ์ง!
์ํ์์๋ ์ด๊ฑธ ๋ณดํต y = f(x) ํํ๋ก ํํํด. ์ฌ๊ธฐ์:
- x๋ ์ ๋ ฅ๊ฐ (๋ ๋ฆฝ๋ณ์)
- y๋ ์ถ๋ ฅ๊ฐ (์ข ์๋ณ์)
- f๋ x๋ฅผ y๋ก ๋ณํํ๋ ๊ท์น
๐ ํจ์์ ์ข ๋ฅ
ํจ์์๋ ์ ๋ง ๋ค์ํ ์ข ๋ฅ๊ฐ ์์ด. ์ฐ๋ฆฌ๊ฐ ๊ทธ๋ผ๋ฐ์ด์ ์ ํํํ๋ ๋ฐ ์ ์ฉํ ์ ์๋ ๋ช ๊ฐ์ง ๊ธฐ๋ณธ์ ์ธ ํจ์๋ค์ ์ดํด๋ณผ๊น?
- ์ ํ ํจ์ (Linear Function): y = mx + b
- ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํจ์ ํํ์ผ.
- ์ง์ ํํ์ ๊ทธ๋ํ๋ฅผ ๊ทธ๋ ค.
- m์ ๊ธฐ์ธ๊ธฐ, b๋ y์ ํธ์ด๋ผ๊ณ ํด.
- ์ด์ฐจ ํจ์ (Quadratic Function): y = axยฒ + bx + c
- ํฌ๋ฌผ์ ๋ชจ์์ ๊ทธ๋ํ๋ฅผ ๊ทธ๋ ค.
- a, b, c์ ๊ฐ์ ๋ฐ๋ผ ๋ชจ์์ด ๋ฌ๋ผ์ ธ.
- ์ง์ ํจ์ (Exponential Function): y = a^x
- ๊ธ๊ฒฉํ๊ฒ ์ฆ๊ฐํ๊ฑฐ๋ ๊ฐ์ํ๋ ๊ทธ๋ํ๋ฅผ ๊ทธ๋ ค.
- a๊ฐ 1๋ณด๋ค ํฌ๋ฉด ์ฆ๊ฐ, 0๊ณผ 1 ์ฌ์ด๋ฉด ๊ฐ์ํด.
- ๋ก๊ทธ ํจ์ (Logarithmic Function): y = log_a(x)
- ์ง์ ํจ์์ ์ญํจ์์ผ.
- ์ฒ์ฒํ ์ฆ๊ฐํ๋ ๊ทธ๋ํ๋ฅผ ๊ทธ๋ ค.
- ์ผ๊ฐ ํจ์ (Trigonometric Functions): sin(x), cos(x), tan(x)
- ์ฃผ๊ธฐ์ ์ผ๋ก ๋ฐ๋ณต๋๋ ํจํด์ ๋ง๋ค์ด๋ด.
- ํ๋๋ ์ง๋ ๊ฐ์ ํ์์ ํํํ๊ธฐ ์ข์.
๐ญ ํจ์์ ๋ณํ
๊ธฐ๋ณธ ํจ์๋ค์ ์กฐ๊ธ์ฉ ๋ณํํ๋ฉด ๋ ๋ค์ํ ๋ชจ์์ ๋ง๋ค ์ ์์ด. ์ฃผ์ํ ๋ณํ ๋ฐฉ๋ฒ๋ค์ ๋ค์๊ณผ ๊ฐ์:
- ์ด๋ (Translation): ๊ทธ๋ํ๋ฅผ ์ํ์ข์ฐ๋ก ์์ง์ฌ.
- ์ ์ถ (Stretching/Compressing): ๊ทธ๋ํ๋ฅผ ๋์ด๊ฑฐ๋ ์ค์ฌ.
- ๋์นญ (Reflection): ๊ทธ๋ํ๋ฅผ x์ถ์ด๋ y์ถ์ ๋ํด ๋ค์ง์ด.
- ํฉ์ฑ (Composition): ๋ ๊ฐ ์ด์์ ํจ์๋ฅผ ์กฐํฉํด.
๐ ํจ์์ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋จ
์ด์ ์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ด ํจ์๋ค์ด ์ด๋ป๊ฒ ๊ทธ๋ผ๋ฐ์ด์ ๊ณผ ์ฐ๊ฒฐ๋๋์ง ์์๋ณผ ์ฐจ๋ก์ผ. ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ๋, ์ฐ๋ฆฌ๋ ์์์ ๋ณํ๋ฅผ ๋ถ๋๋ฝ๊ณ ์์ฐ์ค๋ฝ๊ฒ ๋ง๋ค๊ณ ์ถ์ดํ์ง? ๋ฐ๋ก ์ฌ๊ธฐ์ ํจ์๊ฐ ํฐ ์ญํ ์ ํด!
ํจ์๋ฅผ ์ด์ฉํ๋ฉด ์์์ ๋ณํ ์๋์ ํจํด์ ์ ๊ตํ๊ฒ ์ ์ดํ ์ ์์ด. ์๋ฅผ ๋ค์ด:
- ์ ํ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์ผ์ ํ ์๋๋ก ๋ณํ๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ์ ์์ด.
- ์ด์ฐจ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์์ ๋ณํ๊ฐ ์ ์ ๋นจ๋ผ์ง๊ฑฐ๋ ๋๋ ค์ง๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ์ ์์ง.
- ์ฌ์ธ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์์์ด ๋ถ๋๋ฝ๊ฒ ์๋ค๊ฐ๋ค ํ๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ์ ์์ด.
๐ก ์ฌ๋ฅ๋ท ํ: ์ด๋ฐ ์ํ์ ์ ๊ทผ์ ์ด์ฉํ๋ฉด, ๋จ์ํ '์์' ๊ทธ๋ผ๋ฐ์ด์ ์ ๋์ด์ ์ ํํ๊ณ ์๋์ ์ธ ๋์์ธ์ ๋ง๋ค ์ ์์ด. ์ด๋ ์ ๋ฌธ์ ์ธ ๋์์ธ ์์ ์์ ํฐ ๊ฐ์ ์ด ๋ ์ ์์ง!
๐ง ํจ์๋ฅผ ์ด์ฉํ ๊ทธ๋ผ๋ฐ์ด์ ์์
๊ฐ๋จํ ์์๋ฅผ ํตํด ํจ์๊ฐ ์ด๋ป๊ฒ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ ์ฉ๋๋์ง ์ดํด๋ณผ๊น?
- ์ ํ ๊ทธ๋ผ๋ฐ์ด์
: f(x) = x
- 0์์ 1๊น์ง ์ผ์ ํ ์๋๋ก ๋ณํ
- ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ด๊ณ ๊ท ์ผํ ๊ทธ๋ผ๋ฐ์ด์
- ์ด์ฐจ ๊ทธ๋ผ๋ฐ์ด์
: f(x) = xยฒ
- ์ฒ์์๋ ์ฒ์ฒํ, ๋์ค์๋ ๋น ๋ฅด๊ฒ ๋ณํ
- ๋๋ถ๋ถ์์ ์์ ๋ณํ๊ฐ ๋ ๊ทน์
- ์ฌ์ธ ๊ทธ๋ผ๋ฐ์ด์
: f(x) = (sin(x * ฯ - ฯ/2) + 1) / 2
- ๋ถ๋๋ฝ๊ฒ ์์ํด์ ์ค๊ฐ์ ๋น ๋ฅด๊ฒ, ๋ค์ ๋ถ๋๋ฝ๊ฒ ๋๋จ
- ์์ฐ์ค๋ฌ์ด ๋๋์ ๊ทธ๋ผ๋ฐ์ด์
๐ ํจ์์ ์ค์ ์ ์ฉ
์ค์ ๋ก ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ๋๋ ์ด๋ฐ ํจ์๋ค์ ์ด๋ป๊ฒ ์ฌ์ฉํ ๊น? ๊ฐ๋จํ ์์ ์ฝ๋๋ฅผ ๋ณผ๊น?
function calculateColor(startColor, endColor, t, easingFunction) {
// t๋ 0์์ 1 ์ฌ์ด์ ๊ฐ
const easedT = easingFunction(t);
const r = Math.round(startColor.r + (endColor.r - startColor.r) * easedT);
const g = Math.round(startColor.g + (endColor.g - startColor.g) * easedT);
const b = Math.round(startColor.b + (endColor.b - startColor.b) * easedT);
return `rgb(${r}, ${g}, ${b})`;
}
// ์ด์ง ํจ์ ์์
function linear(t) { return t; }
function quadratic(t) { return t * t; }
function sine(t) { return (Math.sin(t * Math.PI - Math.PI/2) + 1) / 2; }
// ์ฌ์ฉ ์์
const startColor = {r: 255, g: 0, b: 0}; // ๋นจ๊ฐ
const endColor = {r: 0, g: 0, b: 255}; // ํ๋
console.log(calculateColor(startColor, endColor, 0.5, linear)); // ์ค๊ฐ ์์
console.log(calculateColor(startColor, endColor, 0.5, quadratic)); // ์ด์ฐจ ํจ์ ์ ์ฉ
console.log(calculateColor(startColor, endColor, 0.5, sine)); // ์ฌ์ธ ํจ์ ์ ์ฉ
์ด ์ฝ๋์์ easingFunction
์ด ๋ฐ๋ก ์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ด ์ํ ํจ์๋ฅผ ์ ์ฉํ๋ ๋ถ๋ถ์ด์ผ. ์ด ํจ์๋ฅผ ๋ฐ๊พธ๋ฉด ๊ทธ๋ผ๋ฐ์ด์
์ ๋ณํ ํจํด์ด ๋ฌ๋ผ์ง์ง.
๐จ ์ฐฝ์์ ์ธ ๊ทธ๋ผ๋ฐ์ด์ ๋ง๋ค๊ธฐ
์ด์ ๊ธฐ๋ณธ์ ์ธ ํจ์๋ค์ ๋ฐฐ์ ์ผ๋, ์ด๋ฅผ ์กฐํฉํด์ ๋ ๋ณต์กํ๊ณ ์ฐฝ์์ ์ธ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ์ ์์ด. ์๋ฅผ ๋ค์ด:
- ์ฌ๋ฌ ํจ์๋ฅผ ์กฐํฉํด์ ๋ณตํฉ์ ์ธ ํจํด ๋ง๋ค๊ธฐ
- ์ฃผ๊ธฐํจ์๋ฅผ ์ด์ฉํด ๋ฐ๋ณต๋๋ ๊ทธ๋ผ๋ฐ์ด์ ํจํด ๋ง๋ค๊ธฐ
- ๋๋ค ํจ์๋ฅผ ์ถ๊ฐํด์ ์์ฐ์ค๋ฌ์ด ๋ณํ ์ฃผ๊ธฐ
๐ค ์๊ฐํด๋ณด๊ธฐ: ๋๋ง์ ๋ ํนํ ๊ทธ๋ผ๋ฐ์ด์ ํจ์๋ฅผ ๋ง๋ค์ด๋ณผ ์ ์์๊น? ์ด๋ค ์ํ ํจ์๋ค์ ์กฐํฉํ๋ฉด ์ฌ๋ฏธ์๋ ํจ๊ณผ๊ฐ ๋ ์ง ์์ํด๋ด!
์, ์ด์ ์ฐ๋ฆฌ๋ ์ํ ํจ์์ ๊ธฐ์ด์ ๊ทธ๊ฒ์ด ์ด๋ป๊ฒ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ ์ฉ๋๋์ง ์์๋ดค์ด. ๋ค์ ์น์ ์์๋ ์ด ์ง์์ ๋ฐํ์ผ๋ก ์ค์ ๋ก ์์์ ์ํ์ ์ผ๋ก ํํํ๋ ๋ฐฉ๋ฒ์ ๋ํด ๋ ์์ธํ ์์๋ณผ ๊ฑฐ์ผ. ์ค๋น๋๋? ๊ณ์ ๊ฐ๋ณด์! ๐
4. ์์์ ์ํ์ผ๋ก ํํํ๊ธฐ ๐จ
์, ์ด์ ์ฐ๋ฆฌ๋ ์ ๋ง ํฅ๋ฏธ์ง์งํ ๋ถ๋ถ์ ๋๋ฌํ์ด! ๋ฐ๋ก ์์์ ์ํ์ ์ผ๋ก ์ด๋ป๊ฒ ํํํ๋์ง ์์๋ณผ ๊ฑฐ์ผ. ์ด๊ฒ ์ ์ค์ํ ๊น? ์์์ ์ํ์ผ๋ก ํํํ ์ ์๋ค๋ฉด, ์ฐ๋ฆฌ๋ ์ปดํจํฐ๋ฅผ ์ด์ฉํด ์ ํํ๊ณ ๋ค์ํ ์์์ ๋ง๋ค์ด๋ผ ์ ์๊ฑฐ๋ . ๐
๐ข RGB ์์ ๋ชจ๋ธ ๋ค์ ๋ณด๊ธฐ
์ฐ๋ฆฌ๊ฐ ์์ ๋ฐฐ์ ๋ RGB ์์ ๋ชจ๋ธ์ ๊ธฐ์ตํ๋? ์ด ๋ชจ๋ธ์์ ๊ฐ ์์์ ์ธ ๊ฐ์ ์ซ์๋ก ํํ๋ผ:
- R (Red): 0์์ 255 ์ฌ์ด์ ๊ฐ
- G (Green): 0์์ 255 ์ฌ์ด์ ๊ฐ
- B (Blue): 0์์ 255 ์ฌ์ด์ ๊ฐ
์ด ์ธ ๊ฐ์ง ๊ฐ์ ์กฐํฉ์ผ๋ก ์ฐ๋ฆฌ๋ 1600๋ง ๊ฐ์ง๊ฐ ๋๋ ์์์ ํํํ ์ ์์ด! ๐
๐ ๋ฒกํฐ๋ก์์ ์์
์ํ์ ์ผ๋ก ๋ณผ ๋, RGB ์์์ 3์ฐจ์ ๋ฒกํฐ๋ก ์๊ฐํ ์ ์์ด. ๊ฐ ์์ ์ฑ๋ถ(R, G, B)์ด ํ๋์ ์ฐจ์์ ๋ํ๋ด๋ ๊ฑฐ์ง. ์ด๋ ๊ฒ ์๊ฐํ๋ฉด ์์ ๊ฐ์ ์ฐ์ฐ์ ๋ฒกํฐ ์ฐ์ฐ์ผ๋ก ์ฒ๋ฆฌํ ์ ์์ด!
Color = (R, G, B)
์: ๋นจ๊ฐ์ = (255, 0, 0)
์ด๋ก์ = (0, 255, 0)
ํ๋์ = (0, 0, 255)
โ ์์ ์ฐ์ฐ
์์์ ๋ฒกํฐ๋ก ํํํ๋ฉด, ์ฐ๋ฆฌ๋ ๋ฒกํฐ ์ฐ์ฐ์ ์ด์ฉํด ์์์ ์กฐ์ํ ์ ์์ด:
- ์์ ๋ํ๊ธฐ:
(R1, G1, B1) + (R2, G2, B2) = (R1+R2, G1+G2, B1+B2)
๋จ, ๊ฐ ์ฑ๋ถ์ ์ต๋๊ฐ์ 255๋ฅผ ๋์ง ์๋๋ก ํด์ผ ํด.
- ์์ ๋นผ๊ธฐ:
(R1, G1, B1) - (R2, G2, B2) = (R1-R2, G1-G2, B1-B2)
๊ฐ ์ฑ๋ถ์ ์ต์๊ฐ์ 0 ์ดํ๋ก ๋ด๋ ค๊ฐ์ง ์๋๋ก ํด์ผ ํด.
- ์์ ์ค์นผ๋ผ ๊ณฑ:
k * (R, G, B) = (k*R, k*G, k*B)
์ฌ๊ธฐ์ k๋ 0์์ 1 ์ฌ์ด์ ๊ฐ์ด์ผ. ์ด๋ฅผ ํตํด ์์์ ๋ฐ๊ธฐ๋ฅผ ์กฐ์ ํ ์ ์์ง.
๐ ์์ ๋ณด๊ฐ (Color Interpolation)
๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ๋ ๊ฐ์ฅ ์ค์ํ ๊ฐ๋ ์ค ํ๋๊ฐ ๋ฐ๋ก ์์ ๋ณด๊ฐ์ด์ผ. ๋ ์์ ์ฌ์ด์ ์ค๊ฐ ์์์ ๊ณ์ฐํ๋ ๊ณผ์ ์ด์ง. ์ ํ ๋ณด๊ฐ ๊ณต์์ ์ฌ์ฉํ๋ฉด ๋ผ:
์ค๊ฐ์์ = ์์์์ + (๋์์ - ์์์์) * t
์ฌ๊ธฐ์ t๋ 0์์ 1 ์ฌ์ด์ ๊ฐ์ด์ผ.
์ด๋ฅผ RGB ๊ฐ ์ฑ๋ถ์ ์ ์ฉํ๋ฉด:
R = R1 + (R2 - R1) * t
G = G1 + (G2 - G1) * t
B = B1 + (B2 - B1) * t
(R1, G1, B1)์ ์์ ์์
(R2, G2, B2)๋ ๋ ์์
๐ญ ์์ ๊ณต๊ฐ ๋ณํ
๋๋ก๋ RGB ์ธ์ ๋ค๋ฅธ ์์ ๋ชจ๋ธ์ ์ฌ์ฉํด์ผ ํ ๋๊ฐ ์์ด. ์๋ฅผ ๋ค์ด, HSL(Hue, Saturation, Lightness) ๋ชจ๋ธ์ ์์์ ๋ ์ง๊ด์ ์ผ๋ก ์กฐ์ํ ์ ์๊ฒ ํด์ฃผ์ง. RGB์ HSL ์ฌ์ด์ ๋ณํ์ ๋ค์๊ณผ ๊ฐ์ ์ํ์ ๊ณต์์ ์ฌ์ฉํด:
// RGB to HSL
R' = R / 255
G' = G / 255
B' = B / 255
Cmax = max(R', G', B')
Cmin = min(R', G', B')
ฮ = Cmax - Cmin
L = (Cmax + Cmin) / 2
S = ฮ == 0 ? 0 : ฮ / (1 - |2L - 1|)
H = ฮ == 0 ? 0 :
Cmax == R' ? 60 * ((G' - B') / ฮ % 6) :
Cmax == G' ? 60 * ((B' - R') / ฮ + 2) :
60 * ((R' - G') / ฮ + 4)
์ด๋ฐ ๋ณํ์ ํตํด ์ฐ๋ฆฌ๋ ๋ค์ํ ์์ ๋ชจ๋ธ ์ฌ์ด๋ฅผ ์์ ๋กญ๊ฒ ์ค๊ฐ ์ ์์ด. ๊ฐ ๋ชจ๋ธ์ ์์์ ๋ค๋ฃจ๋ ๋ฐ ์์ด ๊ณ ์ ํ ์ฅ์ ์ด ์๊ฑฐ๋ .
๐ก ์ฌ๋ฅ๋ท ํ: ์์ ๊ณต๊ฐ ๋ณํ์ ์ดํดํ๋ฉด, ๋ค์ํ ๋์์ธ ์ํํธ์จ์ด๋ ํ๋ก๊ทธ๋๋ฐ ํ๊ฒฝ์์ ๋ ์ ์ฐํ๊ฒ ์์์ ๋ค๋ฃฐ ์ ์์ด. ์ด๋ ๋์งํธ ์ํธ๋ ์น ๋์์ธ ๋ถ์ผ์์ ํฐ ๊ฐ์ ์ด ๋ ์ ์์ง!
๐ง ์์ ์ง๊ฐ๊ณผ ์ํ
์ธ๊ฐ์ ์์ ์ง๊ฐ์ ์ ํ์ ์ด์ง ์์. ์ฆ, RGB ๊ฐ์ ์ฐ์ ์ ์ธ ์ค๊ฐ๊ฐ์ด ์ฐ๋ฆฌ ๋์ ์ค์ ์ค๊ฐ ์์์ผ๋ก ๋ณด์ด์ง ์์ ์ ์์ด. ์ด๋ฅผ ๋ณด์ ํ๊ธฐ ์ํด ๊ฐ๋ง ๋ณด์ ์ด๋ผ๋ ๊ฐ๋ ์ ์ฌ์ฉํด:
๋ณด์ ๋ ๊ฐ = ์๋ ๊ฐ ^ (1/ฮณ)
์ฌ๊ธฐ์ ฮณ (๊ฐ๋ง)๋ ๋ณดํต 2.2๋ฅผ ์ฌ์ฉํด.
์ด๋ฐ ๋ณด์ ์ ํตํด ์ฐ๋ฆฌ๋ ๋ ์์ฐ์ค๋ฝ๊ณ ๋์ ํธ์ํ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ์ ์์ด.
๐ผ๏ธ ์ค์ ์์ฉ ์์
์ด์ ์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ด ๋ด์ฉ์ ์ค์ ๋ก ์ด๋ป๊ฒ ์ฌ์ฉํ ์ ์๋์ง ๊ฐ๋จํ ์์๋ฅผ ํตํด ์์๋ณผ๊น?
function interpolateColor(color1, color2, factor) {
const r = Math.round(color1.r + factor * (color2.r - color1.r));
const g = Math.round(color1.g + factor * (color2.g - color1.g));
const b = Math.round(color1.b + factor * (color2.b - color1.b));
return { r, g, b };
}
const red = { r: 255, g: 0, b: 0 };
const blue = { r: 0, g: 0, b: 255 };
// ๋นจ๊ฐ์๊ณผ ํ๋์์ ์ค๊ฐ ์์ ๊ณ์ฐ
const purple = interpolateColor(red, blue, 0.5);
console.log(purple); // ์์ ๊ฒฐ๊ณผ: { r: 128, g: 0, b: 128 }
์ด ์ฝ๋๋ ๋ ์์ ์ฌ์ด์ ์ค๊ฐ ์์์ ๊ณ์ฐํด. 'factor' ๊ฐ์ ์กฐ์ ํ๋ฉด ๋ ์์ ์ฌ์ด์ ์ด๋ ์ง์ ์ ์์์ด๋ ๊ณ์ฐํ ์ ์์ง.
๐ค ์๊ฐํด๋ณด๊ธฐ: ์ด ๊ฐ๋ ์ ํ์ฅํด์ ์ธ ๊ฐ ์ด์์ ์์์ผ๋ก ์ด๋ฃจ์ด์ง ๋ณต์กํ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ด๋ป๊ฒ ๋ง๋ค ์ ์์๊น? ํ๋ฒ ์์ํด๋ณด๊ณ , ์ฝ๋๋ก ๊ตฌํํด๋ณผ ์ ์๋ค๋ฉด ๋ ์ข๊ฒ ์ง?
์, ์ด์ ์ฐ๋ฆฌ๋ ์์์ ์ํ์ ์ผ๋ก ์ด๋ป๊ฒ ํํํ๊ณ ์กฐ์ํ ์ ์๋์ง ์์๋ดค์ด. ์ด ์ง์์ ๋ฐํ์ผ๋ก ๋ค์ ์น์ ์์๋ ์ค์ ๋ก ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ ํจ์๋ก ํํํ๋ ๋ฐฉ๋ฒ์ ๋ํด ๋ ์์ธํ ์์๋ณผ ๊ฑฐ์ผ. ์ค๋น๋๋? ๊ณ์ ๊ฐ๋ณด์! ๐
5. ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ ํจ์๋ก ๋ํ๋ด๊ธฐ ๐
๋๋์ด ์ฐ๋ฆฌ์ ์ฌ์ ์ ํต์ฌ์ ๋๋ฌํ์ด! ์ด์ ์ฐ๋ฆฌ๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ค์ ๋ก ์ํ ํจ์๋ก ์ด๋ป๊ฒ ํํํ๋์ง ์์๋ณผ ๊ฑฐ์ผ. ์ด ๋ถ๋ถ์ ์ ๋ง ํฅ๋ฏธ์ง์งํด. ์๋ํ๋ฉด ์ฌ๊ธฐ์ ์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ด ๋ชจ๋ ๊ฒ๋ค์ด ํ๋๋ก ํฉ์ณ์ง๊ฑฐ๋ ! ๐
๐จ ๊ธฐ๋ณธ ๊ทธ๋ผ๋ฐ์ด์ ํจ์
๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํํ์ ๊ทธ๋ผ๋ฐ์ด์ ํจ์๋ ์ด๋ ๊ฒ ํํํ ์ ์์ด:
f(x) = startColor + (endColor - startColor) * x
์ฌ๊ธฐ์ x๋ 0์์ 1 ์ฌ์ด์ ๊ฐ์ด์ผ.
์ด ํจ์๋ ์ ํ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค์ด๋ด. x๊ฐ 0์ผ ๋๋ ์์ ์์, 1์ผ ๋๋ ๋ ์์, ๊ทธ ์ฌ์ด์ ๊ฐ๋ค์ ์ค๊ฐ ์์๋ค์ด ๋๋ ๊ฑฐ์ง.
๐ ๋ค์ํ ๊ทธ๋ผ๋ฐ์ด์ ํจ์๋ค
ํ์ง๋ง ์ฐ๋ฆฌ๋ ์ฌ๊ธฐ์ ๋ฉ์ถ์ง ์์! ๋ค์ํ ์ํ ํจ์๋ฅผ ์ด์ฉํด์ ๋ ํฅ๋ฏธ๋ก์ด ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ์ ์์ด:
- ์ด์ฐจ ํจ์ ๊ทธ๋ผ๋ฐ์ด์
:
f(x) = startColor + (endColor - startColor) * x^2
์ด ํจ์๋ ์ฒ์์๋ ์ฒ์ฒํ, ๋์ค์๋ ๋น ๋ฅด๊ฒ ๋ณํํ๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค์ด๋ด.
- ์ ๊ณฑ๊ทผ ํจ์ ๊ทธ๋ผ๋ฐ์ด์
:
f(x) = startColor + (endColor - startColor) * sqrt(x)
์ด ํจ์๋ ์ฒ์์๋ ๋น ๋ฅด๊ฒ, ๋์ค์๋ ์ฒ์ฒํ ๋ณํํ๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค์ด๋ด.
- ์ฌ์ธ ํจ์ ๊ทธ๋ผ๋ฐ์ด์
:
f(x) = startColor + (endColor - startColor) * (sin(x * ฯ - ฯ/2) + 1) / 2
์ด ํจ์๋ ๋ถ๋๋ฝ๊ฒ ์์ํด์ ์ค๊ฐ์ ๋น ๋ฅด๊ฒ, ๋ค์ ๋ถ๋๋ฝ๊ฒ ๋๋๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค์ด๋ด.
- ์ง์ ํจ์ ๊ทธ๋ผ๋ฐ์ด์
:
f(x) = startColor + (endColor - startColor) * (e^(x*5) - 1) / (e^5 - 1)
์ด ํจ์๋ ์ฒ์์๋ ๋งค์ฐ ์ฒ์ฒํ, ๋์ค์๋ ๋งค์ฐ ๋น ๋ฅด๊ฒ ๋ณํํ๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค์ด๋ด.
๐ ๊ทธ๋ผ๋ฐ์ด์ ํจ์ ์๊ฐํ
์ด ํจ์๋ค์ด ์ด๋ป๊ฒ ์๊ฒผ๋์ง ์๊ฐ์ ์ผ๋ก ํํํด๋ณผ๊น?
๐งฎ ๋ณตํฉ ๊ทธ๋ผ๋ฐ์ด์ ํจ์
๋ ๋ณต์กํ๊ณ ํฅ๋ฏธ๋ก์ด ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค๊ธฐ ์ํด ์ฌ๋ฌ ํจ์๋ฅผ ์กฐํฉํ ์๋ ์์ด:
f(x) = startColor + (endColor - startColor) * (sin(x * ฯ) * x^2 + x) / 2
์ด๋ฐ ๋ณตํฉ ํจ์๋ ๋์ฑ ๋ค์ํ๊ณ ๋ ํนํ ๊ทธ๋ผ๋ฐ์ด์ ํจ๊ณผ๋ฅผ ๋ง๋ค์ด๋ผ ์ ์์ด.
๐ ๋ค์ค ์์ ๊ทธ๋ผ๋ฐ์ด์
์ง๊ธ๊น์ง๋ ๋ ์์ ์ฌ์ด์ ๊ทธ๋ผ๋ฐ์ด์ ๋ง ๋ค๋ค์ง๋ง, ์ค์ ๋ก๋ ์ฌ๋ฌ ์์์ ํฌํจํ๋ ๊ทธ๋ผ๋ฐ์ด์ ๋ ๋ง์ด ์ฌ์ฉ๋ผ. ์ด๋ฅผ ์ํ์ ์ผ๋ก ํํํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น?
function multiColorGradient(colors, x) {
const n = colors.length - 1;
const index = Math.floor(x * n);
const t = (x * n) % 1;
const startColor = colors[index];
const endColor = colors[index + 1];
return startColor + (endColor - startColor) * t;
}
์ด ํจ์๋ ์ฌ๋ฌ ์์์ ์ ๋ ฅ๋ฐ์ x ๊ฐ์ ๋ฐ๋ผ ์ ์ ํ ์ค๊ฐ ์์์ ๊ณ์ฐํด๋ด.
๐ผ๏ธ 2D ๊ทธ๋ผ๋ฐ์ด์
์ง๊ธ๊น์ง๋ 1์ฐจ์ ๊ทธ๋ผ๋ฐ์ด์ ๋ง ๋ค๋ค์ง๋ง, ์ค์ ๋ก๋ 2์ฐจ์ ํ๋ฉด์์์ ๊ทธ๋ผ๋ฐ์ด์ ๋ ๋ง์ด ์ฌ์ฉ๋ผ. ์ด๋ฅผ ์ํ์ ์ผ๋ก ํํํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น?
function radialGradient(centerColor, edgeColor, x, y) {
const distance = Math.sqrt(x*x + y*y); // ์ค์ฌ์ผ๋ก๋ถํฐ์ ๊ฑฐ๋ฆฌ
const t = Math.min(distance, 1); // 0์์ 1 ์ฌ์ด์ ๊ฐ์ผ๋ก ์ ํ
return centerColor + (edgeColor - centerColor) * t;
}
์ด ํจ์๋ ์ค์ฌ์์ ๊ฐ์ฅ์๋ฆฌ๋ก ํผ์ ธ๋๊ฐ๋ ์ํ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค์ด๋ด.
๐ญ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋๋ฉ์ด์
๊ทธ๋ผ๋ฐ์ด์ ์ ์๊ฐ์ ๋ฐ๋ผ ๋ณํ์ํค๋ฉด ๋ฉ์ง ์ ๋๋ฉ์ด์ ํจ๊ณผ๋ฅผ ๋ง๋ค ์ ์์ด. ์ด๋ฅผ ์ํ์ ์ผ๋ก ํํํ๋ฉด:
function animatedGradient(startColor, endColor, time) {
const t = (Math.sin(time) + 1) / 2; // 0์์ 1 ์ฌ์ด๋ฅผ ์ฃผ๊ธฐ์ ์ผ๋ก ๋ณํ
return startColor + (endColor - startColor) * t;
}
์ด ํจ์๋ฅผ ์ด์ฉํ๋ฉด ๋ ์์ ์ฌ์ด๋ฅผ ๋ถ๋๋ฝ๊ฒ ์ค๊ฐ๋ ์ ๋๋ฉ์ด์ ์ ๋ง๋ค ์ ์์ด.
๐ก ์ฌ๋ฅ๋ท ํ: ์ด๋ฐ ์ํ์ ์ ๊ทผ์ ํตํ ๊ทธ๋ผ๋ฐ์ด์ ์์ฑ์ ๋์งํธ ์ํธ, ์น ๋์์ธ, ๊ฒ์ ๊ฐ๋ฐ ๋ฑ ๋ค์ํ ๋ถ์ผ์์ ํ์ฉ๋ ์ ์์ด. ํนํ ์ฌ๋ฅ๋ท์์ ๊ทธ๋ํฝ ๋์์ธ์ด๋ ํ๋ก๊ทธ๋๋ฐ ๊ด๋ จ ์ฌ๋ฅ์ ๊ณต์ ํ ๋ ์ด๋ฐ ๊ณ ๊ธ ๊ธฐ์ ์ ๋ณด์ฌ์ฃผ๋ฉด ์ ๋ง ๋๋ณด์ผ ๊ฑฐ์ผ!
๐งช ์คํ: ๋๋ง์ ๊ทธ๋ผ๋ฐ์ด์ ํจ์ ๋ง๋ค๊ธฐ
์ด์ ์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ด ๋ด์ฉ์ ๋ฐํ์ผ๋ก ์ง์ ๊ทธ๋ผ๋ฐ์ด์ ํจ์๋ฅผ ๋ง๋ค์ด๋ณผ ์ฐจ๋ก์ผ. ์ด๋ค ๋ ํนํ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ์ ์์๊น?
function myCustomGradient(startColor, endColor, x) {
// ์ฌ๊ธฐ์ ๋๋ง์ ์์์ ๋ฃ์ด๋ด!
const t = Math.sin(x * Math.PI) * Math.pow(x, 1/3);
return startColor + (endColor - startColor) * t;
}
// ์ฌ์ฉ ์์
const red = [255, 0, 0];
const blue = [0, 0, 255];
const x = 0.5;
const result = myCustomGradient(red, blue, x);
console.log(result); // ๊ฒฐ๊ณผ ์์ ์ถ๋ ฅ
์ด๋ฐ ์์ผ๋ก ๋ค์ํ ์ํ ํจ์๋ฅผ ์กฐํฉํด์ ๋๋ง์ ๋ ํนํ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค์ด๋ณผ ์ ์์ด. ์ผ๊ฐํจ์, ์ง์ํจ์, ๋ก๊ทธํจ์ ๋ฑ ๋ค์ํ ํจ์๋ฅผ ์คํํด๋ณด๋ฉด ์ฌ๋ฏธ์์ ๊ฑฐ์ผ!
๐ ์์ ๊ณต๊ฐ๊ณผ ๊ทธ๋ผ๋ฐ์ด์
์ง๊ธ๊น์ง๋ ์ฃผ๋ก RGB ์์ ๊ณต๊ฐ์์ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ค๋ค์ง๋ง, ๋ค๋ฅธ ์์ ๊ณต๊ฐ์์๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ์ ์์ด. ์๋ฅผ ๋ค์ด, HSL(Hue, Saturation, Lightness) ์์ ๊ณต๊ฐ์์ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค๋ฉด ์ด๋จ๊น?
function hslGradient(startHSL, endHSL, x) {
const h = startHSL[0] + (endHSL[0] - startHSL[0]) * x;
const s = startHSL[1] + (endHSL[1] - startHSL[1]) * x;
const l = startHSL[2] + (endHSL[2] - startHSL[2]) * x;
return [h, s, l];
}
// ์ฌ์ฉ ์์
const startHSL = [0, 100, 50]; // ๋นจ๊ฐ
const endHSL = [240, 100, 50]; // ํ๋
const x = 0.5;
const result = hslGradient(startHSL, endHSL, x);
console.log(result); // ๊ฒฐ๊ณผ HSL ์์ ์ถ๋ ฅ
HSL ์์ ๊ณต๊ฐ์์์ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋๋ก RGB๋ณด๋ค ๋ ์์ฐ์ค๋ฌ์ด ์์ ๋ณํ๋ฅผ ๋ง๋ค์ด๋ผ ์ ์์ด.
๐ง ๊ทธ๋ผ๋ฐ์ด์ ๊ณผ ์ธ์ง ์ฌ๋ฆฌํ
์์ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ๋ ์ธ๊ฐ์ ์์ ์ง๊ฐ ํน์ฑ์ ๊ณ ๋ คํ๋ ๊ฒ๋ ์ค์ํด. ์๋ฅผ ๋ค์ด, ์ธ๊ฐ์ ๋์ ๋ น์์ ๊ฐ์ฅ ๋ฏผ๊ฐํ๊ณ ํ๋์์ ๊ฐ์ฅ ๋ ๋ฏผ๊ฐํด. ์ด๋ฅผ ๊ณ ๋ คํ ๊ทธ๋ผ๋ฐ์ด์ ํจ์๋ ์ด๋ ๊ฒ ๋ง๋ค ์ ์์ด:
function perceptualGradient(startColor, endColor, x) {
const r = startColor[0] + (endColor[0] - startColor[0]) * x;
const g = startColor[1] + (endColor[1] - startColor[1]) * Math.pow(x, 0.7);
const b = startColor[2] + (endColor[2] - startColor[2]) * Math.pow(x, 1.5);
return [r, g, b];
}
์ด ํจ์๋ ๋ น์ ์ฑ๋ถ์ ๋ณํ๋ฅผ ๋ ๋ถ๋๋ฝ๊ฒ, ํ๋์ ์ฑ๋ถ์ ๋ณํ๋ฅผ ๋ ๊ธ๊ฒฉํ๊ฒ ๋ง๋ค์ด ์ธ๊ฐ์ ๋์ ๋ ์์ฐ์ค๋ฝ๊ฒ ๋ณด์ด๋ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค์ด๋ด.
๐ ๊ฒฐ๋ก : ๋ฌดํํ ๊ฐ๋ฅ์ฑ์ ์ธ๊ณ
์ฐ๋ฆฌ๋ ์ง๊ธ๊น์ง ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ ํจ์๋ก ํํํ๋ ๋ค์ํ ๋ฐฉ๋ฒ๋ค์ ์์๋ดค์ด. ์ด๋ ๋จ์ํ ์์์ ์๋ ๊ฒ ์ด์์ ์๋ฏธ๋ฅผ ๊ฐ์ ธ. ์ํ์ ์ ๊ทผ์ ํตํด ์ฐ๋ฆฌ๋:
- ๋ ์ ๊ตํ๊ณ ๋ณต์กํ ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค ์ ์์ด
- ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ณํ๋ฅผ ์ ํํ๊ฒ ์ ์ดํ ์ ์์ด
- ์ ๋๋ฉ์ด์ ์ด๋ ์ธํฐ๋ํฐ๋ธํ ํจ๊ณผ๋ฅผ ์ฝ๊ฒ ๋ง๋ค ์ ์์ด
- ์ปดํจํฐ ๊ทธ๋ํฝ์ค๋ ๋์งํธ ์ํธ์์ ๋ ์ฐฝ์์ ์ธ ํํ์ด ๊ฐ๋ฅํด์ ธ
์ด ์ง์์ ๋ฐํ์ผ๋ก ๋๋ง์ ๋ ํนํ๊ณ ์๋ฆ๋ค์ด ๊ทธ๋ผ๋ฐ์ด์ ์ ๋ง๋ค์ด๋ณผ ์ ์์ ๊ฑฐ์ผ. ์ฌ๋ฅ๋ท์์ ์ด๋ฐ ๊ธฐ์ ์ ๊ณต์ ํ๋ฉด ๋ง์ ์ฌ๋๋ค์๊ฒ ์๊ฐ์ ์ค ์ ์์ ๊ฑฐ์ผ!
๐ค ์๊ฐํด๋ณด๊ธฐ: ์ง๊ธ๊น์ง ๋ฐฐ์ด ๋ด์ฉ์ ๋ฐํ์ผ๋ก, ์ด๋ค ์๋ก์ด ๊ทธ๋ผ๋ฐ์ด์ ํจ๊ณผ๋ฅผ ๋ง๋ค์ด๋ณผ ์ ์์๊น? ์๋ฅผ ๋ค์ด, ๋ ์จ์ ๋ฐ๋ผ ๋ณํ๋ ๊ทธ๋ผ๋ฐ์ด์ ๋ฐฐ๊ฒฝ์ด๋, ์์ ์ ๋ฆฌ๋ฌ์ ๋ง์ถฐ ๋ณํ๋ ๊ทธ๋ผ๋ฐ์ด์ ๋ฑ์ ์์ํด๋ณผ ์ ์๊ฒ ์ง?
์, ์ด์ ์ฐ๋ฆฌ์ ์ฌ์ ์ด ๊ฑฐ์ ๋๋๊ฐ๊ณ ์์ด. ๋ง์ง๋ง์ผ๋ก ์ด ๋ชจ๋ ๊ฒ์ ์ค์ ๋ก ์ด๋ป๊ฒ ์์ฉํ ์ ์๋์ง ๋ช ๊ฐ์ง ์์๋ฅผ ํตํด ์์๋ณด์. ์ค๋น๋๋? ๊ณ์ ๊ฐ๋ณด์! ๐
6. ์ค์ ์์ฉ ์์ ๐จ
์, ์ด์ ์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ด ๋ชจ๋ ๊ฒ์ ์ค์ ๋ก ์ด๋ป๊ฒ ์ฌ์ฉํ ์ ์๋์ง ๋ช ๊ฐ์ง ์ฌ๋ฏธ์๋ ์์๋ฅผ ํตํด ์์๋ณผ ๊ฑฐ์ผ. ์ด ์์๋ค์ ํตํด ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ์ ํํ์ด ์ผ๋ง๋ ๊ฐ๋ ฅํ๊ณ ์ ์ฉํ์ง ์ง์ ํ์ธํ ์ ์์ ๊ฑฐ์ผ!
๐ 1. ์๊ฐ์ ๋ฐ๋ผ ๋ณํ๋ ํ๋ ๋ฐฐ๊ฒฝ
์น์ฌ์ดํธ๋ ์ฑ์ ๋ฐฐ๊ฒฝ์ผ๋ก ์๊ฐ์ ๋ฐ๋ผ ๋ณํ๋ ํ๋ ์์์ ๊ตฌํํด๋ณด์. ์์นจ, ๋ฎ, ์ ๋ , ๋ฐค์ ์์์ ๋ถ๋๋ฝ๊ฒ ์ ํํ๋ ๊ฑฐ์ผ.
function skyColor(time) {
// time์ 0(์์ )์์ 24(๋ค์๋ ์์ ) ์ฌ์ด์ ๊ฐ
const morning = [135, 206, 235]; // ํ๋์
const noon = [0, 191, 255]; // ๊น์ ํ๋์
const evening = [255, 99, 71]; // ํ ๋งํ ์
const night = [25, 25, 112]; // ๋ฏธ๋๋์ ๋ธ๋ฃจ
let startColor, endColor, t;
if (time < 6) {
startColor = night;
endColor = morning;
t = time / 6;
} else if (time < 12) {
startColor = morning;
endColor = noon;
t = (time - 6) / 6;
} else if (time < 18) {
startColor = noon;
endColor = evening;
t = (time - 12) / 6;
} else {
startColor = evening;
endColor = night;
t = (time - 18) / 6;
}
// ์ฌ์ธ ํจ์๋ฅผ ์ด์ฉํด ๋ถ๋๋ฌ์ด ์ ํ ํจ๊ณผ ์์ฑ
t = (Math.sin(t * Math.PI - Math.PI/2) + 1) / 2;
return startColor.map((start, i) => Math.round(start + (endColor[i] - start) * t));
}
// ์ฌ์ฉ ์์
console.log(skyColor(7)); // ์์นจ 7์์ ํ๋ ์์
console.log(skyColor(14)); // ์คํ 2์์ ํ๋ ์์
console.log(skyColor(20)); // ์ ๋
8์์ ํ๋ ์์
์ด ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์๊ฐ์ ๋ฐ๋ผ ์์ฐ์ค๋ฝ๊ฒ ๋ณํ๋ ํ๋ ์์์ ๋ง๋ค ์ ์์ด. ์น์ฌ์ดํธ๋ ์ฑ์ ๋ฐฐ๊ฒฝ์ผ๋ก ์ฌ์ฉํ๋ฉด ์ ๋ง ๋ฉ์ง ๊ฑฐ์ผ!
๐ 2. ์ธํฐ๋ํฐ๋ธ ์์ ํ๋ ํธ ์์ฑ๊ธฐ
์ฌ์ฉ์๊ฐ ๋ ๊ฐ์ง ์์์ ์ ํํ๋ฉด ๊ทธ ์ฌ์ด์ ๋ค์ํ ์ค๊ฐ ์์์ ์์ฑํ๋ ๋๊ตฌ๋ฅผ ๋ง๋ค์ด๋ณด์.
function generatePalette(color1, color2, steps) {
const palette = [];
for (let i = 0; i < steps; i++) {
const t = i / (steps - 1);
const r = Math.round(color1[0] + (color2[0] - color1[0]) * t);
const g = Math.round(color1[1] + (color2[1] - color1[1]) * t);
const b = Math.round(color1[2] + (color2[2] - color1[2]) * t);
palette.push([r, g, b]);
}
return palette;
}
// ์ฌ์ฉ ์์
const red = [255, 0, 0];
const blue = [0, 0, 255];
const palette = generatePalette(red, blue, 5);
console.log(palette);
// ๊ฒฐ๊ณผ: [[255,0,0], [191,0,64], [128,0,128], [64,0,191], [0,0,255]]
์ด ํจ์๋ฅผ ์ด์ฉํด ๋์์ด๋๋ค์ด ์ฝ๊ฒ ์์ ํ๋ ํธ๋ฅผ ๋ง๋ค ์ ์๋ ์น ๋๊ตฌ๋ฅผ ๊ฐ๋ฐํ ์ ์์ด. ์ฌ๋ฅ๋ท์์ ์ด๋ฐ ๋๊ตฌ๋ฅผ ๊ณต์ ํ๋ฉด ๋ง์ ์ฌ๋๋ค์๊ฒ ์ ์ฉํ ๊ฑฐ์ผ!
๐ต 3. ์์ ์ ๋ฐ์ํ๋ ๊ทธ๋ผ๋ฐ์ด์ ๋ฐฐ๊ฒฝ
์์ ์ ๋นํธ๋ ์๋์ ๋ฐ๋ผ ๋ณํ๋ ๊ทธ๋ผ๋ฐ์ด์ ๋ฐฐ๊ฒฝ์ ๋ง๋ค์ด๋ณด์. ์ด๊ฑด ์กฐ๊ธ ๋ณต์กํ ์ ์์ง๋ง, ์ ๋ง ๋ฉ์ง ํจ๊ณผ๋ฅผ ๋ผ ์ ์์ด!
function musicResponsiveGradient(frequency, volume) {
// frequency: 0 (์ ์) ~ 1 (๊ณ ์)
// volume: 0 (๋ฌด์) ~ 1 (์ต๋ ์๋)
const lowColor = [0, 0, 255]; // ํ๋ (์ ์)
const highColor = [255, 0, 0]; // ๋นจ๊ฐ (๊ณ ์)
const baseColor = [0, 255, 0]; // ์ด๋ก (๊ธฐ๋ณธ)
// ์ฃผํ์์ ๋ฐ๋ฅธ ์์ ๊ณ์ฐ
const freqColor = lowColor.map((low, i) =>
Math.round(low + (highColor[i] - low) * frequency)
);
// ์๋์ ๋ฐ๋ฅธ ์ต์ข
์์ ๊ณ์ฐ
const finalColor = baseColor.map((base, i) =>
Math.round(base + (freqColor[i] - base) * volume)
);
return finalColor;
}
// ์ฌ์ฉ ์์
console.log(musicResponsiveGradient(0.3, 0.7)); // ์ค์ ์, ๊ฝค ํฐ ์๋
console.log(musicResponsiveGradient(0.8, 0.9)); // ๊ณ ์, ํฐ ์๋
์ด ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์์ ํ๋ ์ด์ด๋ ๋น์ฃผ์ผ๋ผ์ด์ ์ ์ ์ฉํด ์์ ์ ๋ฐ์ํ๋ ๋์ ์ธ ๋ฐฐ๊ฒฝ์ ๋ง๋ค ์ ์์ด. ์ ๋ง ๋ฉ์ง ์ฌ์ฉ์ ๊ฒฝํ์ ์ ๊ณตํ ์ ์์ง!
๐ก๏ธ 4. ์จ๋์ ๋ฐ๋ฅธ ์์ ํํ
์จ๋ ๋ฐ์ดํฐ๋ฅผ ์๊ฐ์ ์ผ๋ก ํํํ๋ ๊ทธ๋ผ๋ฐ์ด์ ํจ์๋ฅผ ๋ง๋ค์ด๋ณด์. ์ด๋ฐ ๊ธฐ๋ฅ์ ๋ ์จ ์ฑ์ด๋ ๋ฐ์ดํฐ ์๊ฐํ์ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ ์ ์์ด.
function temperatureColor(temp) {
// temp: ์จ๋ (์ญ์จ)
const cold = [0, 0, 255]; // ํ๋ (์ถ์)
const neutral = [255, 255, 255]; // ํฐ์ (๋ณดํต)
const hot = [255, 0, 0]; // ๋นจ๊ฐ (๋์)
let startColor, endColor, t;
if (temp < 0) {
startColor = cold;
endColor = neutral;
t = (temp + 20) / 20; // -20ยฐC ~ 0ยฐC
} else {
startColor = neutral;
endColor = hot;
t = temp / 40; // 0ยฐC ~ 40ยฐC
}
t = Math.max(0, Math.min(1, t)); // 0๊ณผ 1 ์ฌ์ด๋ก ์ ํ
return startColor.map((start, i) =>
Math.round(start + (endColor[i] - start) * t)
);
}
// ์ฌ์ฉ ์์
console.log(temperatureColor(-10)); // ์ฐจ๊ฐ์ด ์
console.log(temperatureColor(20)); // ์ค๊ฐ ์
console.log(temperatureColor(35)); // ๋ฐ๋ปํ ์
์ด ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์จ๋ ๋ฐ์ดํฐ๋ฅผ ์ง๊ด์ ์ธ ์์์ผ๋ก ํํํ ์ ์์ด. ๋ ์จ ์ฑ์ด๋ ๊ธฐํ ๋ฐ์ดํฐ ์๊ฐํ์ ์ ์ฉํ๋ฉด ์ ๋ณด๋ฅผ ๋ ํจ๊ณผ์ ์ผ๋ก ์ ๋ฌํ ์ ์์ง!
๐๏ธ 5. 3D ๊ทธ๋ํฝ์์์ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ฉ
3D ๊ทธ๋ํฝ์์ ๋ฌผ์ฒด์ ๊น์ด๊ฐ์ ํํํ๊ธฐ ์ํด ๊ทธ๋ผ๋ฐ์ด์ ์ ์ฌ์ฉํ ์ ์์ด. ๊ฐ๋จํ ์์๋ฅผ ๋ณผ๊น?
function depthGradient(depth, maxDepth) {
const nearColor = [255, 255, 255]; // ๊ฐ๊น์ด ๊ณณ: ํฐ์
const farColor = [100, 100, 100]; // ๋จผ ๊ณณ: ํ์
const t = Math.min(depth / maxDepth, 1);
return nearColor.map((near, i) =>
Math.round(near + (farColor[i] - near) * t)
);
}
// ์ฌ์ฉ ์์
console.log(depthGradient(10, 100)); // ๊ฐ๊น์ด ๋ฌผ์ฒด์ ์์
console.log(depthGradient(50, 100)); // ์ค๊ฐ ๊ฑฐ๋ฆฌ ๋ฌผ์ฒด์ ์์
console.log(depthGradient(90, 100)); // ๋จผ ๋ฌผ์ฒด์ ์์
์ด ํจ์๋ฅผ 3D ๋ ๋๋ง ์์ง์ ์ ์ฉํ๋ฉด ๋ฌผ์ฒด์ ๊น์ด๊ฐ์ ๋ ํจ๊ณผ์ ์ผ๋ก ํํํ ์ ์์ด. ๊ฒ์ ๊ฐ๋ฐ์ด๋ 3D ๋ชจ๋ธ๋ง์์ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ ์ ์์ง!
๐จ ๊ฒฐ๋ก : ๋ฌดํํ ๊ฐ๋ฅ์ฑ
์ฐ๋ฆฌ๊ฐ ์ดํด๋ณธ ์ด ์์๋ค์ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ์ ํํ์ด ์ผ๋ง๋ ๋ค์ํ๊ฒ ํ์ฉ๋ ์ ์๋์ง ๋ณด์ฌ์ฃผ๊ณ ์์ด. ์ด๋ฐ ๊ธฐ์ ๋ค์ ๋จ์ํ '์์ ์์'์ ๋ง๋๋ ๊ฒ์ ๋์ด์ ์ ๋ณด๋ฅผ ์ ๋ฌํ๊ณ , ์ฌ์ฉ์ ๊ฒฝํ์ ํฅ์์ํค๋ฉฐ, ๋ณต์กํ ๋ฐ์ดํฐ๋ฅผ ์๊ฐํํ๋ ๋ฐ ์ฌ์ฉ๋ ์ ์์ด.
์ฌ๋ฅ๋ท์์ ์ด๋ฐ ๊ธฐ์ ๋ค์ ๊ณต์ ํ๋ฉด, ๋์์ด๋, ๊ฐ๋ฐ์, ๋ฐ์ดํฐ ๊ณผํ์ ๋ฑ ๋ค์ํ ๋ถ์ผ์ ์ฌ๋๋ค์๊ฒ ์๊ฐ์ ์ค ์ ์์ ๊ฑฐ์ผ. ๊ทธ๋ฆฌ๊ณ ์ด๋ฐ ์ง์์ ๋จ์ํ ๊ธฐ์ ์ ์ธ ๊ฒ์ ๋์ด์ ์ฐฝ์์ฑ์ ์๊ทนํ๊ณ ์๋ก์ด ์์ด๋์ด๋ฅผ ๋ถ๋ฌ์ผ์ผํฌ ์ ์์ด.
์, ์ด์ ์ฐ๋ฆฌ์ ์ฌ์ ์ด ๋๋๊ฐ๊ณ ์์ด. ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ์ ํํ์ ๋ํด ๊น์ด ์๊ฒ ์์๋ดค๊ณ , ์ค์ ์์ฉ ์ฌ๋ก๋ค๋ ์ดํด๋ดค์ด. ์ด ์ง์์ ๋ฐํ์ผ๋ก ๋๋ง์ ๋ ํนํ๊ณ ์ฐฝ์์ ์ธ ํ๋ก์ ํธ๋ฅผ ์์ํด๋ณด๋ ๊ฑด ์ด๋จ๊น? ์ฌ๋ฅ๋ท์์ ๋ค๊ฐ ๋ง๋ ๋ฉ์ง ์ํ๋ค์ ๊ณต์ ํ๋ฉด ์ข์ ๊ฒ ๊ฐ์!
๐ก ์ฌ๋ฅ๋ท ํ: ์ด๋ฐ ๊ณ ๊ธ ๊ธฐ์ ๋ค์ ํ์ฉํ ํ๋ก์ ํธ๋ฅผ ์ฌ๋ฅ๋ท์์ ๊ณต์ ํ๋ฉด, ๋ง์ ์ฌ๋๋ค์ ๊ด์ฌ์ ๋ ์ ์์ ๊ฑฐ์ผ. ์๋ฅผ ๋ค์ด, "์์ ์ ๋ฐ์ํ๋ ์ธํฐ๋ํฐ๋ธ ์น ๋ฐฐ๊ฒฝ ๋ง๋ค๊ธฐ" ๊ฐ์ ์ฃผ์ ๋ก ํํ ๋ฆฌ์ผ์ ์์ฑํ๋ฉด ์ด๋จ๊น? ๋ค๊ฐ ๋ฐฐ์ด ์ง์์ ๋ค๋ฅธ ์ฌ๋๋ค๊ณผ ๋๋๋ฉด์ ๋์์ ๋ค ์ค๋ ฅ๋ ์ธ์ ๋ฐ์ ์ ์์ ๊ฑฐ์ผ!
๊ทธ๋, ์ด์ ์ ๋ง ๋์ด์ผ! ๊ธด ์ฌ์ ์ด์์ง๋ง ์ ๋ง ํฅ๋ฏธ์ง์งํ์ง? ์์์ ๊ทธ๋ผ๋ฐ์ด์ ์ ์ํ์ ํจ์๋ก ํํํ๋ ๋ฐฉ๋ฒ์ ๋ํด ๊น์ด ์๊ฒ ์์๋ดค์ด. ์ด ์ง์์ ํ์ฉํด์ ๋ฉ์ง ์ํ๋ค์ ๋ง๋ค์ด๋ด๊ธธ ๋ฐ๋ผ! ๊ทธ๋ฆฌ๊ณ ์ฌ๋ฅ๋ท์์ ๋ค๊ฐ ๋ง๋ ์ํ๋ค์ ๊ผญ ๊ณต์ ํด์ค. ๋ค๋ฅธ ์ฌ๋๋ค์๊ฒ ์๊ฐ์ ์ฃผ๊ณ , ๋ ๋ค๋ฅธ ์ฌ๋๋ค๋ก๋ถํฐ ์๋ก์ด ์์ด๋์ด๋ฅผ ์ป์ ์ ์์ ๊ฑฐ์ผ. ํญ์ ํธ๊ธฐ์ฌ์ ๊ฐ์ง๊ณ ๊ณ์ ๋ฐฐ์๋๊ฐ๊ธธ ๋ฐ๋ผ! ๐๐