Android 如何在Jetpack composeH中创建具有弯曲末端的六边形形状

你可以用pathEffect = PathEffect.cornerPathEffect(cornerRadius)

@Composable
private fun DrawPolygonPath() {
    var sides by remember { mutableStateOf(3f) }
    var cornerRadius by remember { mutableStateOf(1f) }

    Canvas(modifier = canvasModifier) {
        val canvasWidth = size.width
        val canvasHeight = size.height
        val cx = canvasWidth / 2
        val cy = canvasHeight / 2
        val radius = (canvasHeight - 20.dp.toPx()) / 2
        val path = createPolygonPath(cx, cy, sides.roundToInt(), radius)

        drawPath(
            color = Color.Red,
            path = path,
            style = Stroke(
                width = 4.dp.toPx(),
                pathEffect = PathEffect.cornerPathEffect(cornerRadius)
            )
        )
    }

    Column(modifier = Modifier.padding(horizontal = 20.dp)) {
        Text(text = "Sides ${sides.roundToInt()}")
        Slider(
            value = sides,
            onValueChange = { sides = it },
            valueRange = 3f..12f,
            steps = 10
        )

        Text(text = "CornerRadius ${cornerRadius.roundToInt()}")

        Slider(
            value = cornerRadius,
            onValueChange = { cornerRadius = it },
            valueRange = 0f..50f,
        )
    }
}

和多边形函数

fun createPolygonPath(cx: Float, cy: Float, sides: Int, radius: Float): Path {
    val angle = 2.0 * Math.PI / sides

    return Path().apply {
        moveTo(
            cx + (radius * cos(0.0)).toFloat(),
            cy + (radius * sin(0.0)).toFloat()
        )
        for (i in 1 until sides) {
            lineTo(
                cx + (radius * cos(angle * i)).toFloat(),
                cy + (radius * sin(angle * i)).toFloat()
            )
        }
        close()
    }
}

你可以从线圈中得到ImageBitmap，然后你可以像这样用BlendMode来画它

@Preview
@Composable
fun ImageTest() {
    Column(
        modifier = Modifier.fillMaxSize().padding(32.dp)
    ) {
        val imageBitmap = ImageBitmap.imageResource(R.drawable.avatar_1_raster)

        Box(
            Modifier
                .size(200.dp)
                .border(2.dp, Color.Green)
                .graphicsLayer {
                    compositingStrategy = CompositingStrategy.Offscreen
                }
                .drawWithCache {
                    val canvasWidth = size.width
                    val canvasHeight = size.height
                    val cx = canvasWidth / 2
                    val cy = canvasHeight / 2
                    val radius = canvasHeight / 4
                    val path = createPolygonPath(cx, cy, 6, radius)

                    onDrawWithContent {

                        // Source
                        drawPath(
                            path = path,
                            color = Color.Red,
                            style = Stroke(
                                width = canvasHeight / 2,
                                pathEffect = PathEffect.cornerPathEffect(15f)
                            )
                        )

                        drawCircle(
                            color = Color.Red,
                            radius = 10f
                        )

                        // Destination
                        drawImage(
                            image = imageBitmap,
                            dstSize = IntSize(size.width.toInt(), size.height.toInt()),
                            blendMode = BlendMode.SrcIn
                        )
                    }
                }
        )
    }
}