Android OpenGL触摸反馈

Android OpenGL 触摸交互实现
最新推荐文章于 2024-04-28 18:11:21 发布
最新推荐文章于 2024-04-28 18:11:21 发布
阅读量980 收藏 2
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chennai1101/article/details/76689976
本文介绍如何在Android平台上利用OpenGL ES实现触摸交互功能，包括触摸事件处理、触摸点到三维射线的转换、物体的移动等关键技术点。

Android OpenGL触摸反馈

首先申明下，本文为笔者学习《OpenGL ES应用开发实践指南》的笔记，并加入笔者自己的理解和归纳总结。

1、添加触摸支持

通过调用setOnTouchListener方法监听视图的触控事件，然后把触控位置转化为[-1, 1]的归一化设备坐标，最后转发给渲染器。
private OpenGLTouchShaderRender mTouchShaderRender;

mSurfaceView.setOnTouchListener(new View.OnTouchListener() {
	@Override
	public boolean onTouch(View v, MotionEvent event) {
		if (event != null) {
			final float normalizedX = (event.getX() / (float) v.getWidth()) * 2 - 1;
			final float normalizedY = -((event.getY() / (float) v.getHeight()) * 2 - 1);

			if (event.getAction() == MotionEvent.ACTION_DOWN) {
				mSurfaceView.queueEvent(new Runnable() {
					@Override
					public void run() {
						if (mTouchShaderRender != null)
							mTouchShaderRender.handleTouchPress(normalizedX, normalizedY);
					}
				});
			} else if (event.getAction() == MotionEvent.ACTION_MOVE) {
				mSurfaceView.queueEvent(new Runnable() {
					@Override
					public void run() {
						if (mTouchShaderRender != null)
							mTouchShaderRender.handleTouchDrag(normalizedX, normalizedY);
					}
				});
			}
			return true;
		}
		return false;
	}
});

2、二维点扩展成三维直线

当我们把一个三维场景投递到二维屏幕的时候，我们使用透视投影和透视除法把顶点坐标变换为归一化设备坐标。
现在我们有被触摸点的归一化设备坐标，为了把为触摸点转换为一个三维射线，我们需要取消透视投影和透视除法。

private final float[] invertedViewProjectMatrix = new float[16];
Matrix.invertM(invertedViewProjectMatrix, 0, viewProjectMatrix, 0);
为了把被触摸点映射到一条射线，我们在归一化设备坐标里设置了两个点：其中一个点是z值为-1，而另一个点是z值为1的点。
private Geometry.Ray convertNormalized2DPointToRay(float normalizedX, float normalizedY) {
	final float[] nearPointNdc = {normalizedX, normalizedY, -1, 1};
	final float[] farPointNdc = {normalizedX, normalizedY, 1, 1};

	final float[] nearPointWorld = new float[4];
	final float[] farPointWorld = new float[4];
	
	Matrix.multiplyMV(nearPointWorld, 0, invertedViewProjectMatrix, 0, nearPointNdc, 0);
	Matrix.multiplyMV(farPointWorld, 0, invertedViewProjectMatrix, 0, farPointNdc, 0);

	// 把x, y, z除以这些反转的w，这样就撤销了透视除法的影响
	divideByW(nearPointWorld);
	divideByW(farPointWorld);

	Geometry.Point nearPointRay =
			new Geometry.Point(nearPointWorld[0], nearPointWorld[1], nearPointWorld[2]);
	Geometry.Point farPointRay =
			new Geometry.Point(farPointWorld[0], farPointWorld[1], farPointWorld[2]);

	// 返回两点之间的射线
	return new Geometry.Ray(nearPointRay,
			Geometry.vectorBetween(nearPointRay, farPointRay));
}

private void divideByW(float[] vector) {
	vector[0] /= vector[3];
	vector[1] /= vector[3];
	vector[2] /= vector[3];
}
在Geometry中定义射线类Ray，矢量类Vector
public static class Ray {
	public final Point point;
	public final Vector vector;

	public Ray(Point point, Vector vector) {
		this.point = point;
		this.vector = vector;
	}
}

public static class Vector  {
	public final float x, y, z;

	public Vector(float x, float y, float z) {
		this.x = x;
		this.y = y;
		this.z = z;
	}
	
}

public static Vector vectorBetween(Point from, Point to) {
	return new Vector(to.x - from.x, to.y - from.y, to.z - from.z);
}

3、相交测试

我们假定木锥是一个球体，这样相交测试就会相当容易。
在onSurfaceCreated中定义蓝色木锥初始位置
blueMalletPoint = new Geometry.Point(0, -0.4f, mMallet.height / 2);
定义一个球体，判断是否与射线相交
Geometry.Sphere malletBoundingSphere = new Geometry.Sphere(blueMalletPoint, mMallet.height/2);
malletPressed = Geometry.intersects(malletBoundingSphere, ray);
主要方法是计算圆心到射线之间的距离，和圆的半径比较。而这个距离是三角形的面积*2/射线长度。里面的数学原理笔者也不是很明白，只能照搬过来。

public static boolean intersects(Sphere sphere, Ray ray) {
	return distanceBetween(sphere.center, ray) < sphere.radius;
}

private static float distanceBetween(Point point, Ray ray) {
	Vector p1ToPoint = vectorBetween(ray.point, point);
	Vector p2ToPoint = vectorBetween(ray.point.translate(ray.vector), point);

	float areaOfTriangleTimesTwo = p1ToPoint.crossProduct(p2ToPoint).length();
	float lengthOfBase = ray.vector.length();

	float distanceFromPointToRay = areaOfTriangleTimesTwo / lengthOfBase;

	return distanceFromPointToRay;
}
Vector类
public static class Vector  {

	public float length() {
		return (float)Math.sqrt(
				x * x  + y * y + z * z);
	}

	public Vector crossProduct(Vector other) {
		return new Vector(
				(y * other.z) - (z * other.y),
				(z * other.x) - (x * other.z),
				(x * other.y) - (y * other.x));
	}

}

4、移动物体

首先需要手指按住木锥，然后把拖动的点转换成射线，找到这条射线和桌子的相交点，最后把木锥移动到那个点。
public void handleTouchDrag(float normalizedX, float normalizedY) {
	if (malletPressed) {
		Geometry.Ray ray = convertNormalized2DPointToRay(normalizedX, normalizedY);

		// 平面位于(0, 0, 0)，有一个法向向量(0, 0, 1)
		Geometry.Plane plane = new Geometry.Plane(new Geometry.Point(0, 0, 0),
				new Geometry.Vector(0, 0, 1));
		Geometry.Point touchedPoint = Geometry.intersectionPoint(ray, plane);
		blueMalletPoint = new Geometry.Point(touchedPoint.x, touchedPoint.y,
				mMallet.height/2f);
	}
}
Plane类，定义了一个平面，它包含一个法向向量和平面上一个点
public static class Plane {
	public final Point point;
	public final Vector normal;

	public Plane(Point point, Vector normal) {
		this.point = point;
		this.normal = normal;
	}
}
intersectionPoint计算相交点，里面的数学原理笔者也不是很明白，只能照搬过来。
public static Point intersectionPoint(Ray ray, Plane plane) {
	Vector rayToPlaneVector = vectorBetween(ray.point, plane.point);

	float scaleFactor = rayToPlaneVector.dotProduct(plane.normal)
			/ ray.vector.dotProduct(plane.normal);

	Point intersectionPoint = ray.point.translate(ray.vector.scale(scaleFactor));
	return intersectionPoint;
}
Vector类
public static class Vector  {

	public float dotProduct(Vector other) {
		return x * other.x + y * other.y + z * other.z;
	}

	public Vector scale(float f) {
		return new Vector(x * f, y * f, z * f);
	}
}

5、OpenGLTouchShaderRender类

class OpenGLTouchShaderRender implements GLSurfaceView.Renderer {
	private boolean malletPressed = false;
	private Geometry.Point blueMalletPoint;

	private final float[] invertedViewProjectionMatrix = new float[16];

	private final float[] projectionMatrix = new float[16];
	private final float[] modelMatrix = new float[16];
	private final float[] viewMatrix = new float[16];
	private final float[] viewProjectionMatrix = new float[16];
	private final float[] modelViewProjectionMatrix = new float[16];

	private TextureProgram mTextureProgram;
	private GeometryColorProgram mColorProgram;

	private Table mTable;
	private GeometryMallet mMallet;

	@Override
	public void onSurfaceCreated(GL10 gl, EGLConfig config) {
		GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

		mTable = new Table();

		// 创建木锥
		ResourceDataBuilder.ResourceData data = ResourceDataBuilder.createMallet(
				new Geometry.Cylinder(new Geometry.Point(0f, 0f, 0f), 0.08f, 0.15f), 32);
		mMallet = new GeometryMallet(data, 0.08f, 0.15f);
		blueMalletPoint = new Geometry.Point(0, -0.4f, mMallet.height / 2);

		mTextureProgram = new TextureProgram(OpenGLTouchShaderActivity.this,
				R.drawable.air_hockey_surface);
		mColorProgram = new GeometryColorProgram(OpenGLTouchShaderActivity.this);
	}

	@Override
	public void onSurfaceChanged(GL10 gl, int width, int height) {
		GLES20.glViewport(0, 0, width, height);

		// 创建透视投影
		Matrix.perspectiveM(projectionMatrix, 0, 45, (float)width / (float)height, 1, 10);
		Matrix.setLookAtM(viewMatrix, 0, 0f, -2.4f, 1.4f, 0f, 0f, 0f, 0f, 1f, 0f);

		Matrix.multiplyMM(viewProjectionMatrix, 0, projectionMatrix, 0, viewMatrix, 0);
		Matrix.invertM(invertedViewProjectionMatrix, 0, viewProjectionMatrix, 0);
	}

	@Override
	public void onDrawFrame(GL10 gl) {
		GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);

		// 绘制桌子
		positionTableInScene();
		mTextureProgram.setUniform(modelViewProjectionMatrix);
		mTable.bindData(mTextureProgram);
		mTable.draw();

		// 绘制蓝色木锥
		positionObjectInScene(blueMalletPoint.x, blueMalletPoint.y,  blueMalletPoint.z);
		mColorProgram.setUniform(modelViewProjectionMatrix);
		mColorProgram.setColor(0f, 0f, 1f);
		mMallet.bindData(mColorProgram);
		mMallet.draw();
	}

	private void positionTableInScene() {
		Matrix.setIdentityM(modelMatrix, 0);
		Matrix.multiplyMM(modelViewProjectionMatrix, 0, viewProjectionMatrix,
				0, modelMatrix, 0);
	}

	// 移动木锥
	private void positionObjectInScene(float x, float y, float z) {
		Matrix.setIdentityM(modelMatrix, 0);
		Matrix.translateM(modelMatrix, 0, x, y, z);
		Matrix.multiplyMM(modelViewProjectionMatrix, 0, viewProjectionMatrix,
				0, modelMatrix, 0);
	}

	public void handleTouchPress(float normalizedX, float normalizedY) {
		Geometry.Ray ray = convertNormalized2DPointToRay(normalizedX, normalizedY);
		// 定义一个球体，判断是否与射线相交
		Geometry.Sphere malletBoundingSphere = new Geometry.Sphere(blueMalletPoint, mMallet.height/2);
		malletPressed = Geometry.intersects(malletBoundingSphere, ray);
		LogUtil.log("OpenGLTouchShaderRender", "pressed: " + malletPressed);
	}

	public void handleTouchDrag(float normalizedX, float normalizedY) {
		if (malletPressed) {
			Geometry.Ray ray = convertNormalized2DPointToRay(normalizedX, normalizedY);

			Geometry.Plane plane = new Geometry.Plane(new Geometry.Point(0, 0, 0),
					new Geometry.Vector(0, 0, 1));
			Geometry.Point touchedPoint = Geometry.intersectionPoint(ray, plane);
			blueMalletPoint = new Geometry.Point(touchedPoint.x, touchedPoint.y,
					mMallet.height/2f);
		}
	}

	private Geometry.Ray convertNormalized2DPointToRay(float normalizedX, float normalizedY) {
		LogUtil.log("OpenGLTouchShaderRender", "normalizedX: " + normalizedX);
		LogUtil.log("OpenGLTouchShaderRender", "normalizedY: " + normalizedY);
		final float[] nearPointNdc = {normalizedX, normalizedY, -1, 1};
		final float[] farPointNdc = {normalizedX, normalizedY, 1, 1};

		final float[] nearPointWorld = new float[4];
		final float[] farPointWorld = new float[4];

		Matrix.multiplyMV(nearPointWorld, 0, invertedViewProjectionMatrix, 0, nearPointNdc, 0);
		Matrix.multiplyMV(farPointWorld, 0, invertedViewProjectionMatrix, 0, farPointNdc, 0);

		// 把x, y, z除以这些反转的w，这样就撤销了透视除法的影响
		divideByW(nearPointWorld);
		divideByW(farPointWorld);

		Geometry.Point nearPointRay =
				new Geometry.Point(nearPointWorld[0], nearPointWorld[1], nearPointWorld[2]);
		Geometry.Point farPointRay =
				new Geometry.Point(farPointWorld[0], farPointWorld[1], farPointWorld[2]);

		// 返回两点之间的射线
		return new Geometry.Ray(nearPointRay,
				Geometry.vectorBetween(nearPointRay, farPointRay));

	}

	private void divideByW(float[] vector) {
		vector[0] /= vector[3];
		vector[1] /= vector[3];
		vector[2] /= vector[3];
	}

}

6、Geometry类

public class Geometry {

    public static class Point {
        public final float x, y, z;
        public Point(float x, float y, float z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }

        // Z轴平移
        public Point translateZ(float distance) {
            return new Point(x, y, z + distance);
        }

        // 添加translate方法
        public Point translate(Vector vector) {
            return new Point(x + vector.x, y + vector.y, z + vector.z);
        }

    }

    public static class Circle {
        public final Point center;
        public final float radius;

        public Circle(Point center, float radius) {
            this.center = center;
            this.radius = radius;
        }

        // 缩放半径
        public Circle scale(float scale) {
            return new Circle(center, radius * scale);
        }
    }

    public static class Cylinder {
        public final Point center;
        public final float radius;
        public final float height;

        public Cylinder(Point center, float radius, float height) {
            this.center = center;
            this.radius = radius;
            this.height = height;
        }
    }

    public static class Ray {
        public final Point point;
        public final Vector vector;

        public Ray(Point point, Vector vector) {
            this.point = point;
            this.vector = vector;
        }
    }

    public static class Vector  {
        public final float x, y, z;

        public Vector(float x, float y, float z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }

        public float length() {
            return (float)Math.sqrt(
                    x * x  + y * y + z * z);
        }

        // http://en.wikipedia.org/wiki/Cross_product
        public Vector crossProduct(Vector other) {
            return new Vector(
                    (y * other.z) - (z * other.y),
                    (z * other.x) - (x * other.z),
                    (x * other.y) - (y * other.x));
        }

        // http://en.wikipedia.org/wiki/Dot_product
        public float dotProduct(Vector other) {
            return x * other.x + y * other.y + z * other.z;
        }

        public Vector scale(float f) {
            return new Vector(x * f, y * f, z * f);
        }
    }

    public static class Sphere {
        public final Point center;
        public final float radius;

        public Sphere(Point center, float radius) {
            this.center = center;
            this.radius = radius;
        }
    }

    public static class Plane {
        public final Point point;
        public final Vector normal;

        public Plane(Point point, Vector normal) {
            this.point = point;
            this.normal = normal;
        }
    }

    public static Vector vectorBetween(Point from, Point to) {
        return new Vector(to.x - from.x, to.y - from.y, to.z - from.z);
    }

    public static boolean intersects(Sphere sphere, Ray ray) {
        return distanceBetween(sphere.center, ray) < sphere.radius;
    }

    private static float distanceBetween(Point point, Ray ray) {
        Vector p1ToPoint = vectorBetween(ray.point, point);
        Vector p2ToPoint = vectorBetween(ray.point.translate(ray.vector), point);

        float areaOfTriangleTimesTwo = p1ToPoint.crossProduct(p2ToPoint).length();
        float lengthOfBase = ray.vector.length();

        float distanceFromPointToRay = areaOfTriangleTimesTwo / lengthOfBase;

        return distanceFromPointToRay;
    }

    public static Point intersectionPoint(Ray ray, Plane plane) {
        Vector rayToPlaneVector = vectorBetween(ray.point, plane.point);

        float scaleFactor = rayToPlaneVector.dotProduct(plane.normal)
                / ray.vector.dotProduct(plane.normal);

        Point intersectionPoint = ray.point.translate(ray.vector.scale(scaleFactor));
        return intersectionPoint;
    }

}
显示如下

Android 的触摸反馈以及事件分发机制
qq_48021641的博客
06-23 1240
事件分发
Android surfaceview使用——重载onTouchEvent
a11123939的专栏
04-26 4413
surface上绘制bitmap，同时重载onTouchEnvetpublic class bmpdrow extends SurfaceView implements SurfaceHolder.Callback { private Bitmap bmp; private Resources res; private SurfaceHolder holder; priva
android 触屏反馈原理
sir_zeng的专栏
10-10 3551
在用户对软按键或者某些ui操作的时候会反馈振动，达到让用户感知操作ok的效果。 在情景模式(Audio Profile)的选取之后，将会出现对特定情景模式设置的界面(Edit Profile),在这里面就可以设置是否启动振动器 和反馈功能。 情景模式对于的代码在：packages/apps/Settings/src/com/android/settings/audioprofile下， 其
Android OpenGL ES 入门系列（七） --- 响应触摸事件
Hansion的博客
01-22 811
转载请注明出处 本文出自Hansion的博客 设置触摸监听 想要响应用户的触摸事件，需要重写GLSurfaceView的onTouchEvent()方法： public class MyGLSurfaceView extends GLSurfaceView { private final float TOUCH_SCALE_FA
android opengl 点击,Android---OpenGL ES之响应触屏事件
weixin_36013970的博客
05-26 458
像旋转三角形那样，让对象根据预设的程序来移动，以便有助于获取人们的关注，但是如 果想要让你的OpenGL ES图形跟用户交互，应该怎样做呢?要让你的OpenGL ES应用程序能够触碰交互的关键是扩展你的GLSurfaceView实现，重写它的onTouchEvent()方法来监听触碰事件。本文介绍如何监听触碰事件，让用户可以旋转OpenGL ES对象。设置触碰监听器为了让你的OpenGL ES应...
android 屏幕反馈 即时音效
Zophar_Development的博客
04-17 1632
目前在做智能家居相关产品，移动端采用APICloud+android 原生模块开发。下面我来说说为什么要做这个自定义的屏幕反馈、即时音效。首先原生的提示音被各大厂商封装又封装，导致开发者拿不到手机原生的屏幕反馈的提示声，更多的还是通知栏的声音，并且就算拿得到，适配也会更让人头疼的。还有在播放音频文件时。文件的格式还有学问：（我这里用的是wav格式，我也忘记在哪看到一篇博客，说是最好用wav的，解决...
Android 使用opengl写动态壁纸的类库.zip
07-10
这为动态壁纸带来了更丰富的用户体验，用户可以通过触摸与壁纸互动，如改变壁纸的动画效果或触发某些特定的视觉反馈。 在实际开发中，为了提高性能和避免过度绘制，你需要优化你的OpenGL ES代码。这可能包括减少...
Android OpenGL动态壁纸开发类库使用教程
10. 发布和管理：了解如何将开发完成的动态壁纸打包发布到Google Play或其他Android应用市场，并跟踪用户反馈进行后续更新和管理。 以上知识点为开发Android动态壁纸应用类库的基础，掌握这些知识点对于开发高质量...
Android应用源码[开源项目]_炫酷的3D音乐播放器_各种特效OpenGL.zip
12-04
这个开源项目是一个基于Android平台的3D音乐播放器，它运用了OpenGL技术来实现炫酷的视觉效果。从源码中，我们可以深入学习Android应用开发的相关知识，特别是关于图形渲染和用户界面设计的部分。以下是对这个项目的...
【Android应用源码】opengl小怪兽3D源码.zip
最新发布
07-27
本压缩包文件提供的“【Android应用源码】opengl小怪兽3D源码.zip”是一套针对Android平台的OpenGL ES应用开发资源，它包含了一套完整的3D动画效果实现，具体可以涉及到以下几个知识点： 1. Android平台开发基础：...
android触摸轨迹
07-26
在Android平台上，触摸事件是用户与设备交互的重要方式，而触摸轨迹的绘制则可以为用户提供直观的视觉反馈，尤其在游戏或创意应用中，如画板或者模拟水果忍者的刀切效果。本知识点主要探讨如何在Android中实现触摸...
OpenGL ES2.0入门之Android篇(二)——添加动作及触摸事件
lb377463323的博客
08-06 3845
上篇文章中介绍了如何使用OpenGL ES2.0绘制三角形，本章将在上篇的基础上进行讲解，另附链接 OpenGL ES2.0入门之Android篇(一)——绘制三角形) 定义投影和相机视图 在OpenGL ES环境中，投影和相机视图让绘制对象以更接近于人们肉眼所看到的实物对象的样子显示 投影： 前文讲过，Android和OpenGL ES的坐标系不一样，如果没有投影的话，绘制的图像将会被拉伸变形
Android 振动和触感反馈功能失效问题分析
不要用过去的错误约束现在的自己。
04-28 1492
如果Log中打印振动时常为20毫秒的话，亲测是没有任何振动触感的，所以我们延长振动的时间(单位为毫秒)，具体的值要根据自己的需求来修改(本人项目最后修改的是80毫秒)，当时我的项目只需要修改WAVEFORM_CLICK_EFFECT = 80即可生效。在Android13的项目中遇到这样一个问题，在设置 - 提示音和振动 - 振动和触感反馈 - 打开按触反馈，但是按键没有振动的效果(一般来说也就是三个导航按键的振动反馈)
Android Studio屏幕点击与OpenGL ES的交互
Tokyo_2024的博客
08-26 574
1.MainActivity部分： package com.opengles.graphics.myapplication; import android.app.Activity; import android.os.Bundle; public class MainActivity extends Activity { private ClearGLSurfaceView mG...
Android屏幕坐标与OpenGL ES视口坐标的转换
(ง •̀_•́)ง
11-23 4221
在Android opengl编程中，涉及到手指触摸屏幕事件，就不可避免地需要解决两种坐标转换的问题。         先定义类内的全局变量，表示OpenGL所在区域的屏幕宽高。 private int w; private int h;         然后找到重绘的函数，加上一句 w = width , h = height，以获取屏幕宽高。（注意不能直接获取安卓屏幕宽高，它还包
matrix知识点小记
hyjwan的博客
07-09 2475
最近从github上面下载了一个手势与view交互的组件StickerView，里面有一块关于矩阵的代码没看明白，研究了下矩阵。 可以参考 http://my.oschina.net/lifj/blog/175114 http://blog.sina.com.cn/s/blog_783ede030102w6we.html Matrix 在View进行缩放，旋转，移动时会用到。
Matrix类中Invert（）的用法
茄克不爱说话
07-05 9739
昨天在编程过程中，使用到了一个新的类Matrix中的一个方法Invert（）。 以前没见过，单词也没印象，所以我就查找资料，结果发现这居然是一个矩阵，但是我发现例子中Matrix的构造函数是： Matrix m = new Matrix(1, 2, 3, 4, 0, 0); 但是构造函数的解释是Encapsulates a 3-by-3 affine matrix that re
openGL坐标系
weixin_33716941的博客
10-31 342
从我们构造模型的局部坐标系（Local/Object Space）经过一系列的处理最终渲染到屏幕坐标系(Screen Space)下,这个过程有6种坐标系。 一、世界坐标系（World Coordinates） 学名：右手笛卡尔坐标系统。 在OpenGL中，世界坐标系是以屏幕中心为原点(0, 0, 0)，且是始终不变的。x轴正方向为屏幕从左向右，y轴正方向为屏幕从下向上，z轴正方向为屏幕从里...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值