Merge branch 'kotlin-1.8' into kotlin-1.9

build.gradle

@@ -2,7 +2,7 @@ apply plugin: "net.minecraftforge.gradle.forge"
 apply plugin: 'kotlin'
 
 group = 'com.github.octarine-noise'
-version = "2.0.11"
+version = "2.0.14"
 archivesBaseName = rootProject.name + '-MC1.9'
 
 buildscript {

src/main/kotlin/mods/betterfoliage/BetterFoliageMod.kt

@@ -39,7 +39,7 @@ object BetterFoliageMod {
     @Mod.EventHandler
     fun preInit(event: FMLPreInitializationEvent) {
         log = event.modLog
-        config = Configuration(event.suggestedConfigurationFile, null, true)
+        config = Configuration(event.suggestedConfigurationFile, null, false)
 
     }
 

src/main/kotlin/mods/betterfoliage/client/config/Config.kt

@@ -43,6 +43,7 @@ object Config : DelegatingConfig(BetterFoliageMod.MOD_ID, BetterFoliageMod.DOMAI
 
     object leaves {
         val enabled by featureEnable()
+        val snowEnabled by boolean(true)
         val distance by distanceLimit()
         val hOffset by double(max=0.4, default=0.2).lang("hOffset")
         val vOffset by double(max=0.4, default=0.1).lang("vOffset")

src/main/kotlin/mods/betterfoliage/client/integration/OptifineCTM.kt

@@ -22,8 +22,12 @@ import org.apache.logging.log4j.Level.INFO
 @SideOnly(Side.CLIENT)
 object OptifineCTM {
 
-    val isAvailable = allAvailable(Refs.ConnectedTextures, Refs.ConnectedProperties, Refs.getConnectedTexture,
-        Refs.CTblockProperties, Refs.CTtileProperties, Refs.CPtileIcons, Refs.CPmatchesBlock, Refs.CPmatchesIcon)
+    val isAvailable = allAvailable(
+        Refs.ConnectedTextures, Refs.ConnectedProperties,
+        Refs.getConnectedTexture,
+        Refs.CTblockProperties, Refs.CTtileProperties,
+        Refs.CPtileIcons, Refs.CPmatchesIcon
+    )
 
     init {
         Client.log(INFO, "Optifine CTM support is ${if (isAvailable) "enabled" else "disabled" }")
@@ -45,7 +49,7 @@ object OptifineCTM {
     /** Get all the CTM [TextureAtlasSprite]s that could possibly be used for this block. */
     fun getAllCTM(state: IBlockState, icon: TextureAtlasSprite): Collection<TextureAtlasSprite> {
         val result = hashSetOf<TextureAtlasSprite>()
-        if (state !is BlockStateBase) return result
+        if (state !is BlockStateBase || !isAvailable) return result
 
         connectedProperties.forEach { cp ->
             if (Refs.CPmatchesBlock.invoke(cp, Refs.getBlockId.invoke(state), Refs.getMetadata.invoke(state)) as Boolean &&

src/main/kotlin/mods/betterfoliage/client/render/AbstractRenderColumn.kt

@@ -1,14 +1,12 @@
 package mods.betterfoliage.client.render
 
 import mods.betterfoliage.client.config.BlockMatcher
+import mods.betterfoliage.client.integration.OptifineCTM
 import mods.betterfoliage.client.render.AbstractRenderColumn.BlockType.*
 import mods.betterfoliage.client.render.AbstractRenderColumn.QuadrantType.*
 import mods.octarinecore.client.render.*
 import mods.octarinecore.client.resource.BlockTextureInspector
-import mods.octarinecore.common.Int3
-import mods.octarinecore.common.Rotation
-import mods.octarinecore.common.face
-import mods.octarinecore.common.rot
+import mods.octarinecore.common.*
 import net.minecraft.block.state.IBlockState
 import net.minecraft.client.renderer.BlockRendererDispatcher
 import net.minecraft.client.renderer.VertexBuffer
@@ -18,18 +16,34 @@ import net.minecraft.util.BlockRenderLayer
 import net.minecraft.util.EnumFacing
 import net.minecraft.util.EnumFacing.*
 
-data class ColumnInfo(val topTexture: TextureAtlasSprite,
-                      val bottomTexture: TextureAtlasSprite,
-                      val sideTexture: TextureAtlasSprite)
+interface ColumnTextureResolver {
+    val top: (ShadingContext, Int, Quad)->TextureAtlasSprite?
+    val bottom: (ShadingContext, Int, Quad)->TextureAtlasSprite?
+    val side: (ShadingContext, Int, Quad)->TextureAtlasSprite?
+}
 
-open class ColumnTextures(val matcher: BlockMatcher) : BlockTextureInspector<ColumnInfo>() {
+data class StaticColumnInfo(val topTexture: TextureAtlasSprite,
+                            val bottomTexture: TextureAtlasSprite,
+                            val sideTexture: TextureAtlasSprite) : ColumnTextureResolver {
+    override val top = { ctx: ShadingContext, idx: Int, quad: Quad ->
+        OptifineCTM.override(topTexture, blockContext, UP.rotate(ctx.rotation))
+    }
+    override val bottom = { ctx: ShadingContext, idx: Int, quad: Quad ->
+        OptifineCTM.override(bottomTexture, blockContext, DOWN.rotate(ctx.rotation))
+    }
+    override val side = { ctx: ShadingContext, idx: Int, quad: Quad ->
+        OptifineCTM.override(sideTexture, blockContext, (if ((idx and 1) == 0) SOUTH else EAST).rotate(ctx.rotation))
+    }
+}
+
+open class ColumnTextures(val matcher: BlockMatcher) : BlockTextureInspector<StaticColumnInfo>() {
     init {
         matchClassAndModel(matcher, "block/column_side", listOf("end", "end", "side"))
         matchClassAndModel(matcher, "block/cube_column", listOf("end", "end", "side"))
         matchClassAndModel(matcher, "block/cube_all", listOf("all", "all", "all"))
     }
     override fun processTextures(state: IBlockState, textures: List<TextureAtlasSprite>, atlas: TextureMap) =
-        ColumnInfo(textures[0], textures[1], textures[2])
+        StaticColumnInfo(textures[0], textures[1], textures[2])
 }
 
 /** Index of SOUTH-EAST quadrant. */
@@ -120,14 +134,14 @@ abstract class AbstractRenderColumn(modId: String) : AbstractBlockRenderingHandl
     abstract val axisFunc: (IBlockState)->EnumFacing.Axis?
     abstract val blockPredicate: (IBlockState)->Boolean
 
-    abstract val sideTexture: (ShadingContext, Int, Quad)->TextureAtlasSprite?
-    abstract val upTexture: (ShadingContext, Int, Quad)->TextureAtlasSprite?
-    abstract val downTexture: (ShadingContext, Int, Quad)->TextureAtlasSprite?
+    abstract fun resolver(ctx: BlockContext): ColumnTextureResolver?
 
     @Suppress("NON_EXHAUSTIVE_WHEN")
     override fun render(ctx: BlockContext, dispatcher: BlockRendererDispatcher, renderer: VertexBuffer, layer: BlockRenderLayer): Boolean {
         if (ctx.isSurroundedBy(surroundPredicate) ) return false
 
+        val columnTextures = resolver(ctx) ?: return false
+
         // get AO data
         modelRenderer.updateShading(Int3.zero, allFaces)
 
@@ -170,15 +184,15 @@ abstract class AbstractRenderColumn(modId: String) : AbstractBlockRenderingHandl
                 sideModel,
                 rotation,
                 blockContext.blockCenter,
-                icon = sideTexture,
+                icon = columnTextures.side,
                 postProcess = noPost
             )
 
             // render top and bottom end of current quadrant
             var upModel: Model? = null
             var downModel: Model? = null
-            var upIcon = upTexture
-            var downIcon = downTexture
+            var upIcon = columnTextures.top
+            var downIcon = columnTextures.bottom
             var isLidUp = true
             var isLidDown = true
 
@@ -188,7 +202,7 @@ abstract class AbstractRenderColumn(modId: String) : AbstractBlockRenderingHandl
                     if (!connectPerpendicular) {
                         upModel = flatTop(quadrants[idx])
                     } else {
-                        upIcon = sideTexture
+                        upIcon = columnTextures.side
                         upModel = extendTop(quadrants[idx])
                         isLidUp = false
                     }
@@ -207,7 +221,7 @@ abstract class AbstractRenderColumn(modId: String) : AbstractBlockRenderingHandl
                     if (!connectPerpendicular) {
                         downModel = flatBottom(quadrants[idx])
                     } else {
-                        downIcon = sideTexture
+                        downIcon = columnTextures.side
                         downModel = extendBottom(quadrants[idx])
                         isLidDown = false
                     }

src/main/kotlin/mods/betterfoliage/client/render/RenderLeaves.kt

@@ -67,7 +67,7 @@ class RenderLeaves : AbstractBlockRenderingHandler(BetterFoliageMod.MOD_ID) {
                     }
                 )
             }
-            if (isSnowed) modelRenderer.render(
+            if (isSnowed && Config.leaves.snowEnabled) modelRenderer.render(
                 renderer,
                 leavesModel.model,
                 Rotation.identity,

src/main/kotlin/mods/betterfoliage/client/render/RenderLog.kt

@@ -42,6 +42,8 @@ class RenderLog : AbstractRenderColumn(BetterFoliageMod.MOD_ID) {
         }
     }
 
+    override fun resolver(ctx: BlockContext): ColumnTextureResolver? = columnTextures[ctx.blockState(Int3.zero)]
+
     override val blockPredicate = { state: IBlockState -> Config.blocks.logs.matchesID(state.block) }
     override val surroundPredicate = { state: IBlockState -> state.isOpaqueCube && !Config.blocks.logs.matchesID(state.block) }
 
@@ -51,21 +53,4 @@ class RenderLog : AbstractRenderColumn(BetterFoliageMod.MOD_ID) {
     override val radiusLarge: Double get() = Config.roundLogs.radiusLarge
     override val radiusSmall: Double get() = Config.roundLogs.radiusSmall
 
-    override val downTexture = { ctx: ShadingContext, idx: Int, quad: Quad ->
-        columnTextures[ctx.blockData(Int3.zero).state]?.bottomTexture?.let { base ->
-            OptifineCTM.override(base, blockContext, DOWN.rotate(ctx.rotation))
-        }
-    }
-
-    override val sideTexture = { ctx: ShadingContext, idx: Int, quad: Quad ->
-        columnTextures[ctx.blockData(Int3.zero).state]?.sideTexture?.let { base ->
-            OptifineCTM.override(base, blockContext, (if ((idx and 1) == 0) SOUTH else EAST).rotate(ctx.rotation))
-        }
-    }
-
-    override val upTexture = { ctx: ShadingContext, idx: Int, quad: Quad ->
-        columnTextures[ctx.blockData(Int3.zero).state]?.topTexture?.let { base ->
-            OptifineCTM.override(base, blockContext, UP.rotate(ctx.rotation))
-        }
-    }
 }

src/main/kotlin/mods/octarinecore/metaprog/Reflection.kt

@@ -89,6 +89,14 @@ class ClassRefPrimitive(name: String, val clazz: Class<*>?) : ClassRef(name) {
     override fun resolve() = clazz
 }
 
+class ClassRefArray(mcpName: String, obfName: String) : ClassRef(mcpName, obfName) {
+    constructor(mcpName: String) : this(mcpName, mcpName)
+    override fun asmDescriptor(namespace: Namespace) = "[" + super.asmDescriptor(namespace)
+    override fun resolve() = listOf(mcpName, obfName).map { getJavaClass("[L$it;") }.filterNotNull().firstOrNull()
+}
+
+fun ClassRef.array() = ClassRefArray(mcpName, obfName)
+
 /**
  * Reference to a method.
  *

src/main/resources/assets/betterfoliage/lang/en_US.lang

@@ -87,6 +87,8 @@ betterfoliage.leaves=Extra Leaves
 betterfoliage.leaves.tooltip=Extra round leaves on leaf blocks
 betterfoliage.leaves.dense=Dense mode
 betterfoliage.leaves.dense.tooltip=Dense mode has more round leaves
+betterfoliage.leaves.snowEnabled=Enable snow
+betterfoliage.leaves.snowEnabled.tooltip=Enable snow on extra leaves?
 
 betterfoliage.shortGrass=Short Grass & Mycelium
 betterfoliage.shortGrass.tooltip=Tufts of grass/mycelium on top of appropriate blocks

src/main/resources/assets/betterfoliage/lang/ko_KR.lang

@@ -0,0 +1,216 @@
+key.betterfoliage.gui=설정
+
+betterfoliage.global.enabled=모드 활성화
+betterfoliage.global.enabled.tooltip=비활성화 할 경우, 환경강화모드 렌더링이 보이지 않습니다.
+
+betterfoliage.enabled=활성화
+betterfoliage.enabled.tooltip=이 기능이 활성화 되어 있습니까?
+betterfoliage.hOffset=수평(가로) 상쇄시키다
+betterfoliage.hOffset.tooltip=이 성분이 블럭 수평으로 이동된다.
+betterfoliage.vOffset=수직(세로) 상쇄시키다
+betterfoliage.vOffset.tooltip=이 성분이 블럭 수직으로 이동된다.
+betterfoliage.size=사이즈(크기)
+betterfoliage.size.tooltip=사이즈(크기)의 최소
+betterfoliage.heightMin=최소한 높이
+betterfoliage.heightMin.tooltip=높이 최소한의 최소
+betterfoliage.heightMax=최대한 높이
+betterfoliage.heightMax.tooltip=높이 최대한의 최소
+betterfoliage.population=주민
+betterfoliage.population.tooltip=자격을 갖춘 블럭의 기능 확률(N 분의 64)
+betterfoliage.shaderWind=쉐이더 바람 효과
+betterfoliage.shaderWind.tooltip=바람효과를 쉐이더에 적용시키겠습니까?
+betterfoliage.distance=거리 제한
+betterfoliage.distance.tooltip=이 기능을 렌더링하는 플레이어의 최대거리
+
+betterfoliage.blocks=블록 타입
+betterfoliage.blocks.tooltip=세팅 된 것에 따라 블록이 바뀔 것입니다.
+
+betterfoliage.blocks.dirtWhitelist=흙 허용목록
+betterfoliage.blocks.dirtBlacklist=흙 차단목록
+betterfoliage.blocks.dirtWhitelist.arrayEntry=%d entries
+betterfoliage.blocks.dirtBlacklist.arrayEntry=%d entries
+
+betterfoliage.blocks.grassWhitelist=잔디 허용목록
+betterfoliage.blocks.grassBlacklist=잔디 차단목록
+betterfoliage.blocks.grassWhitelist.arrayEntry=%d entries
+betterfoliage.blocks.grassBlacklist.arrayEntry=%d entries
+
+betterfoliage.blocks.leavesWhitelist=잎 허용목록
+betterfoliage.blocks.leavesBlacklist=잎 차단목록
+betterfoliage.blocks.leavesWhitelist.arrayEntry=%d entries
+betterfoliage.blocks.leavesBlacklist.arrayEntry=%d entries
+
+betterfoliage.blocks.cropsWhitelist=농작물 허용목록
+betterfoliage.blocks.cropsBlacklist=농작물 차단목록
+betterfoliage.blocks.cropsWhitelist.arrayEntry=%d entries
+betterfoliage.blocks.cropsBlacklist.arrayEntry=%d entries
+
+betterfoliage.blocks.logsWhitelist=나무 허용목록
+betterfoliage.blocks.logsBlacklist=나무 차단목록
+betterfoliage.blocks.logsWhitelist.arrayEntry=%d entries
+betterfoliage.blocks.logsBlacklist.arrayEntry=%d entries
+
+betterfoliage.blocks.sandWhitelist=모래 허용목록
+betterfoliage.blocks.sandBlacklist=모래 차단목록
+betterfoliage.blocks.sandWhitelist.arrayEntry=%d entries
+betterfoliage.blocks.sandBlacklist.arrayEntry=%d entries
+
+betterfoliage.blocks.lilypadWhitelist=연꽃 허용목록
+betterfoliage.blocks.lilypadBlacklist=연꽃 차단목록
+betterfoliage.blocks.lilypadWhitelist.arrayEntry=%d entries
+betterfoliage.blocks.lilypadBlacklist.arrayEntry=%d entries
+
+betterfoliage.blocks.cactusWhitelist=선인장 허용목록
+betterfoliage.blocks.cactusBlacklist=선인장 차단목록
+betterfoliage.blocks.cactusWhitelist.arrayEntry=%d entries
+betterfoliage.blocks.cactusBlacklist.arrayEntry=%d entries
+
+
+betterfoliage.blocks.dirtWhitelist.tooltip=흙으로 인식됩니다. 갈대, 조류, 잔디 텍스쳐 연결에 영향을 줍니다.
+betterfoliage.blocks.dirtBlacklist.tooltip=흙으로 인식 되지 않습니다. 갈대, 조류, 잔디 텍스쳐 연결에 영향을 주지 않습니다.
+betterfoliage.blocks.grassWhitelist.tooltip=잔디로 인식됩니다. 짧은 잔디, 잔디 텍스쳐 연결에 영향을 줍니다.
+betterfoliage.blocks.grassBlacklist.tooltip=잔디로 인식 되지 않습니다. 짧은 잔디, 잔디 텍스쳐 연결에 영향을 주지 않습니다.
+betterfoliage.blocks.leavesWhitelist.tooltip=잎으로 인식됩니다. 추가 잎, 떨어지는 잎에 영향을 줍니다. 
+betterfoliage.blocks.leavesBlacklist.tooltip=잎으로 인식 되지 않습니다. 추가 잎, 떨어지는 잎에 영향을 주지 않습니다.
+betterfoliage.blocks.cropsWhitelist.tooltip=농작물로 인식됩니다. 농작물은 쉐이더 적용하면 큰잔디로 렌더링 됩니다. 
+betterfoliage.blocks.cropsBlacklist.tooltip=농작물로 인식 되지 않습니다. 농작물은 쉐이더 적용하면 큰잔디로 렌더링 되지 않습니다.
+betterfoliage.blocks.logsWhitelist.tooltip=나무로 인식됩니다. 둥근 나무에 영향을 줍니다.
+betterfoliage.blocks.logsBlacklist.tooltip=나무로 인식 되지 않습니다. 둥근 나무에 영향을 주지 않습니다.
+betterfoliage.blocks.sandWhitelist.tooltip=모래로 인식됩니다. 산호에 영향을 줍니다
+betterfoliage.blocks.sandBlacklist.tooltip=모래로 인식되지 않습니다. 산호에 영향을 주지 않습니다.
+betterfoliage.blocks.lilypadWhitelist.tooltip=연꽃으로 인식됩니다. 보다 나은 연꽃에 영향을 줍니다.
+betterfoliage.blocks.lilypadBlacklist.tooltip=연꽃으로 인식되지 않습니다. 보다 나은 연꽃에 영향을 주지 않습니다.
+betterfoliage.blocks.cactusWhitelist.tooltip=선인장으로 인식됩니다. 보다 나은 선인장에 영향을 줍니다.
+betterfoliage.blocks.cactusBlacklist.tooltip=선인장으로 인식되지 않습니다. 보다 나은 선인장에 영향을 주지 않습니다.
+
+betterfoliage.leaves=잎 추가
+betterfoliage.leaves.tooltip=둥글게 나뭇잎을 추가시켜줍니다.
+betterfoliage.leaves.dense=조밀한 모드
+betterfoliage.leaves.dense.tooltip=조밀한 모드는 둥근 나뭇잎을 더 추가시켜줍니다.
+
+betterfoliage.shortGrass=이쁜 잔디 & 균사체
+betterfoliage.shortGrass.tooltip=블록 상단에 잔디 / 균사체
+betterfoliage.shortGrass.useGenerated=잔디텍스쳐를 활성화 합니다.
+betterfoliage.shortGrass.useGenerated.tooltip=소스팩의 일부분에 활성화 되어있는 큰잔디 텍스쳐를 생성시킵니다.
+betterfoliage.shortGrass.myceliumEnabled=균사체 활성화
+betterfoliage.shortGrass.myceliumEnabled.tooltip=균사체 블록에 있는 기능을 활성화 시키겠습니까?
+betterfoliage.shortGrass.grassEnabled=잔디 활성화
+betterfoliage.shortGrass.grassEnabled.tooltip=잔디 블록에 있는 기능을 활성화 시키겠습니까?
+betterfoliage.shortGrass.snowEnabled=눈 활성화
+betterfoliage.shortGrass.snowEnabled.tooltip=잔디 블록위에 있는 눈을 활성화 시키겠습니까?
+betterfoliage.shortGrass.saturationThreshold=채도 임계값
+betterfoliage.shortGrass.saturationThreshold.tooltip=(특정 색상을 사용하여)"무채색"블록과 (바이옴 색을 사용하여)"화려한"블록 사이의 채도 차단
+
+betterfoliage.hangingGrass=매달려있는 잔디
+betterfoliage.hangingGrass.tooltip=잔디 블록 상단 가장자리에서 아래로 매달려 있는 잔디 다발
+betterfoliage.hangingGrass.separation=분리
+betterfoliage.hangingGrass.separation.tooltip=잔디블럭에 매달려있는 잔디의 양 
+
+betterfoliage.cactus=선인장
+betterfoliage.cactus.tooltip=선인장의 비트 수와 부드러운 그림자를 추가
+betterfoliage.cactus.sizeVariation=사이즈 변화
+betterfoliage.cactus.sizeVariation.tooltip=선인장의 사이즈 크기를 무작위 변화 시킵니다.
+
+betterfoliage.lilypad=연꽃잎
+betterfoliage.lilypad.tooltip=연꽃의 뿌리와 약간의 꽃 추가
+betterfoliage.lilypad.flowerChance=꽃 확률
+betterfoliage.lilypad.flowerChance.tooltip=연꽃 위에 있는 꽃 확률(N 분의 64)
+
+betterfoliage.reed=갈대
+betterfoliage.reed.tooltip=물 속에서 흙블럭 위에 있는 갈대
+betterfoliage.reed.biomes=바이옴 리스트
+betterfoliage.reed.biomes.tooltip=갈대를 바이옴에 따라 표시
+betterfoliage.reed.biomes.tooltip.element=갈대를 %s 바이옴에 따라 나타내시겠습니까? 
+
+betterfoliage.algae=해조류
+betterfoliage.algae.tooltip=깊은 물 속 흙 블럭 위에 있는 해조류
+betterfoliage.algae.biomes=바이옴 리스트
+betterfoliage.algae.biomes.tooltip=해조류를 바이옴에 따라 표시
+betterfoliage.algae.biomes.tooltip.element=해조류를 %s 바이옴에 따라 나타내시겠습니까? 
+
+betterfoliage.coral=산호
+betterfoliage.coral.tooltip=깊은 물 속 모래 블럭 위에있는 산호
+betterfoliage.coral.size=산호 사이즈(크기)
+betterfoliage.coral.size.tooltip=산호 이미지만큼 적용
+betterfoliage.coral.crustSize=껍질 크기
+betterfoliage.coral.crustSize.tooltip=산호 부분의 크기 
+betterfoliage.coral.chance=산호 확률
+betterfoliage.coral.chance.tooltip=산호를 특정블록에 표시하는 확률(N 분의 64)
+betterfoliage.coral.biomes=바이옴 리스트
+betterfoliage.coral.biomes.tooltip=산호를 바이옴에 따라 표시
+betterfoliage.coral.biomes.tooltip.element=산호를 %s 바이옴에 따라 나타내시겠습니까?
+betterfoliage.coral.shallowWater=얕은 물 산호
+betterfoliage.coral.shallowWater.tooltip=산호를 깊은 물에 표시하시겠습니까?
+
+betterfoliage.netherrack=네더랙 덩굴
+betterfoliage.netherrack.tooltip=네더랙에 매달려있는 덩굴
+
+betterfoliage.fallingLeaves=떨어지는 나뭇잎
+betterfoliage.fallingLeaves.tooltip=잎 블록에서 바닥으로 떨어지는 잎 파티클
+betterfoliage.fallingLeaves.speed=파티클 속도
+betterfoliage.fallingLeaves.speed.tooltip=전체 파티클 속도
+betterfoliage.fallingLeaves.windStrength=바람 세기
+betterfoliage.fallingLeaves.windStrength.tooltip=날씨 바람 추가효과 (0을 중심으로 정규분포의 확산)
+betterfoliage.fallingLeaves.stormStrength=폭풍 세기
+betterfoliage.fallingLeaves.stormStrength.tooltip=비 날씨에 바람 추가효과 (0을 중심으로 정규분포의 확산)
+betterfoliage.fallingLeaves.size=파티클 크기
+betterfoliage.fallingLeaves.chance=파티클 확률
+betterfoliage.fallingLeaves.chance.tooltip=잎 파티클 랜덤 확률 설정
+betterfoliage.fallingLeaves.perturb=움직임
+betterfoliage.fallingLeaves.perturb.tooltip=움직임 효과의 크기. 코르크 같은 움직임을 추가합니다.
+betterfoliage.fallingLeaves.lifetime=파티클 지속시간
+betterfoliage.fallingLeaves.lifetime.tooltip=최대 파티클 지속시간을 설정합니다. 최소 지속시간은 60%입니다.
+betterfoliage.fallingLeaves.opacityHack=불투명 파티클
+betterfoliage.fallingLeaves.opacityHack.tooltip=파티클이 앞에 있어도 파티클을 가리는 투명블럭을 없앱니다. 경고: 오류주의
+
+betterfoliage.risingSoul=소울 상승
+betterfoliage.risingSoul.tooltip=소울 블럭에서 올라오는 파티클
+betterfoliage.risingSoul.chance=파티클 수정
+betterfoliage.risingSoul.chance.tooltip=소울 파티클 랜덤 확률 설정
+betterfoliage.risingSoul.speed=파티클 속도
+betterfoliage.risingSoul.speed.tooltip=파티클 속도
+betterfoliage.risingSoul.perturb=움직임
+betterfoliage.risingSoul.perturb.tooltip=움직임 효과의 크기. 코르크 같은 움직임을 추가합니다.
+betterfoliage.risingSoul.headSize=소울 크기
+betterfoliage.risingSoul.headSize.tooltip=소울 파티클의 크기
+betterfoliage.risingSoul.trailSize=자취 사이즈
+betterfoliage.risingSoul.trailSize.tooltip=자취의 크기
+betterfoliage.risingSoul.opacity=불투명
+betterfoliage.risingSoul.opacity.tooltip=파티클의 불투명
+betterfoliage.risingSoul.sizeDecay=크기 감소
+betterfoliage.risingSoul.sizeDecay.tooltip=상대적인 자취 파티클 크기
+betterfoliage.risingSoul.opacityDecay=불투명 감소
+betterfoliage.risingSoul.opacityDecay.tooltip=상대적인 입자의 파티클 불투명도
+betterfoliage.risingSoul.lifetime=최대 지속시간
+betterfoliage.risingSoul.lifetime.tooltip=최대 파티클 지속시간을 설정합니다. 최소 지속시간은 60%입니다.
+betterfoliage.risingSoul.trailLength=자취의 세기
+betterfoliage.risingSoul.trailLength.tooltip=이전 파티클 틱으로 자취를 생성합니다.
+betterfoliage.risingSoul.trailDensity=자취의 밀도
+betterfoliage.risingSoul.trailDensity.tooltip=파티클 자취를 모두 렌더링 합니다.
+
+betterfoliage.connectedGrass=잔디 연결 텍스쳐
+betterfoliage.connectedGrass.enabled=활성화
+betterfoliage.connectedGrass.enabled.tooltip=잔디블록이 흙블록 위에 있을 경우 잔디블록 윗텍스쳐를 옆텍스쳐에 전부 씌웁니다.
+
+betterfoliage.roundLogs=둥근 나무
+betterfoliage.roundLogs.tooltip=둥근부분을 블럭과 연결.
+betterfoliage.roundLogs.connectSolids=블럭과 연결
+betterfoliage.roundLogs.connectSolids.tooltip=둥근부분을 블럭과 연결.
+betterfoliage.roundLogs.connectPerpendicular=나무 세로부분과 연결
+betterfoliage.roundLogs.connectPerpendicular.tooltip=나무 세로부분을 나무부분끼리 연결
+betterfoliage.roundLogs.lenientConnect=부드럽게 둥글게 연결
+betterfoliage.roundLogs.lenientConnect.tooltip=2x2사이즈처럼 나무 평형된 부분끼리 서로 연결합니다.
+betterfoliage.roundLogs.connectGrass=잔디 연결 텍스쳐
+betterfoliage.roundLogs.connectGrass.tooltip=잔디가 근처에 있을 경우 나무 아래 잔디 블록을 렌더링
+betterfoliage.roundLogs.radiusSmall=모서리 깎는 반지름
+betterfoliage.roundLogs.radiusSmall.tooltip=나무 모서리 깎는 정도
+betterfoliage.roundLogs.radiusLarge=모서리 깎는 부분 연결
+betterfoliage.roundLogs.radiusLarge.tooltip=나무 모서리 부분을 연결
+betterfoliage.roundLogs.dimming=조광
+betterfoliage.roundLogs.dimming.tooltip=나무 표면부분을 어둡게하는 양
+betterfoliage.roundLogs.zProtection=Z-Protection
+betterfoliage.roundLogs.zProtection.tooltip=Amount to scale parallel log connection bits to stop Z-fighting (flickering). Try to set it as high as possible without having glitches.
+betterfoliage.roundLogs.defaultY=수직선에대한 기본값
+betterfoliage.roundLogs.defaultY.tooltip=true 일경우, 나무 블럭이 수직선에대한 렌더링을 할수가 없습니다. 그렇지 아니하면, 네모난 블럭으로 렌더링 될것임니다.
+
+# Translate by IS_Jump for feedback mail acarus22@gmail.com