鸿蒙Harmony开发实战案例：使用OpenGL绘制3D图形

xcomponent控件常用于相机预览流的显示和游戏画面的绘制,在openharmony上，可以配合native window创建opengl开发环境，并最终将opengl绘制的图形显示到xcomponent控件。本文将采用"native c++"模板，调用opengl es图形库绘制3d图形（三棱锥），并将结果渲染到页面的xcomponent控件中进行展示。同时，还可以在屏幕上通过触摸滑动手势对三棱锥进行旋转，最终得到不同角度的图形并显示到页面。

效果展示

环境要求

• 本示例仅支持在标准系统上运行。

• ide：deveco studio 3.1 beta2

• sdk：ohos_sdk_public 3.2.11.9 (api version 9 release)

点击领取→纯血鸿蒙next全套最新学习资料  希望这一份鸿蒙学习资料能够给大家带来帮助，有需要的小伙伴自行领取，限时开源，先到先得~无套路领取！！

开发步骤

1、环境搭建

我们首先要完成应用开发环境的搭建，本示例运行dayu200开发板上。

• 搭建应用开发环境

  

  （2）开发环境配置完成后，创建工程（模板选择“native c++”)，选择ets语言开发。

• 应用调测工程创建完成后，选择使用真机进行调测。

  （1）将搭载openharmony标准系统的开发板与电脑连接。

  （2）点击file> project structure... > project>signingconfigs界面勾选“automatically generate signature”，等待自动签名完成即可，最后点击“ok”。如下图所示：

  

  （3）在编辑窗口右上角的工具栏，点击"运行"按钮运行。

  

2、源码结构

• 代码结构分析，整个工程的代码结构如下：

  

• 文件说明如下：

  .
  └── main
      ├── cpp
      │   ├── app_napi.cpp      //c++与arkts中xcomponent控件交互的napi接口实现
      │   ├── cmakelists.txt    //cmake规则配置文件，napi c/c++代码编译需要配置该文件
      │   ├── include
      │   │   ├── app_napi.h
      │   │   ├── tetrahedron.h //三棱锥类实现头文件
      │   │   └── util
      │   ├── module.cpp        //napi模块注册
      │   ├── napi_manager.cpp
      │   ├── napi_util.cpp
      │   ├── tetrahedron.cpp   //三棱锥的绘制opengl实现
      │   └── type
      │       └── libentry
      ├── ets
      │   ├── entryability
      │   │   └── entryability.ts
      │   └── pages
      │       └── index.ets      //主页面
      ├── module.json5
      └── resources              //资源文件目录
          ├── base
          │   ├── element
          │   ├── media
          │   └── profile
          ├── en_us
          │   └── element
          ├── rawfile
          └── zh_cn
              └── element

3、绘制流程

• 3d绘制函数调用流程如下：

• 在tetrahedron类的update方法中使用gles3库着色器绘制，最终通过arkui的xcomponent组件显示，流程如下：

4、c++（opengl）实现

c++端方法源码是工程的entry/src/main/cpp/tetrahedron.cpp文件。

• 注册模块先定义一个模块，在entry/src/main/cpp/module.cpp文件中，对应结构体类型为napi_module，模块定义好后，调用napi提供的模块注册函数napi_module_register(napi_module* mod)注册到系统中；

  /*
   * napi module define
   */
  static napi_module appnapimodule = {
      .nm_version = 1,
      .nm_flags = 0,
      .nm_filename = nullptr,
      .nm_register_func = init,
      .nm_modname = "tetrahedron_napi",
      .nm_priv = ((void*)0),
      .reserved = { 0 },
  };
  
  /*
   * module register function
   */
  extern "c" __attribute__((constructor)) void registermodule(void)
  {
      napi_module_register(&appnapimodule);
  }

• 调用opengl相关图形api绘制三棱锥

  （1）初始化

  int32_t tetrahedron::init(void *window, int32_t width,  int32_t height)
  {
      window_ = window;
      width_ = width;
      height_ = height;
  
      logi("init window = %{public}p, w = %{public}d, h = %{public}d.", window, width, height);
      meglwindow = reinterpret_cast<eglnativewindowtype>(window);
  
      // 1. create sharedcontext
      megldisplay = eglgetdisplay(egl_default_display);
      if (megldisplay == egl_no_display) {
          loge("unable to get egl display.");
          return -1;
      }
  
      eglint eglmajvers, eglminvers;
      if (!eglinitialize(megldisplay, &eglmajvers, &eglminvers)) {
          megldisplay = egl_no_display;
          loge("unable to initialize display");
          return -1;
      }
  
      int version = 3;
      meglconfig = getconfig(version, megldisplay);
      if (meglconfig == nullptr) {
          loge("glcontextinit config error");
          return -1;
      }
  
      // 2. create egl surface from native window
      eglint winattribs[] = {egl_gl_colorspace_khr, egl_gl_colorspace_srgb_khr, egl_none};
      if (meglwindow) {
          meglsurface = eglcreatewindowsurface(megldisplay, meglconfig, meglwindow, winattribs);
          if (meglsurface == nullptr) {
              loge("eglcreatecontext eglsurface is null");
              return -1;
          }
      }
  
      // 3. create eglcontext from
      int attrib3_list[] = {
          egl_context_client_version, 2,
          egl_none
      };
  
      meglcontext = eglcreatecontext(megldisplay, meglconfig, msharedeglcontext, attrib3_list);
      if (!eglmakecurrent(megldisplay, meglsurface, meglsurface, meglcontext)) {
          loge("eglmakecurrent error = %{public}d", eglgeterror());
      }
  
      mprogramhandle = createprogram(vertexshader, fragmentshader);
      if (!mprogramhandle) {
          loge("could not create createprogram");
          return -1;
      }
  
      logi("init success.");
  
      return 0;
  }

  其中，顶点着色器实现如下：

  char vertexshader[] =
      "attribute  vec4 apos;\n"
      "attribute  vec4 a_color;\n"
      "attribute  vec4 a_normal;\n"
      "uniform vec3 u_lightcolor;\n"
      "uniform vec3 u_lightdirection;\n"
      "uniform mat4 a_mx;\n"
      "uniform mat4 a_my;\n"
      "varying  vec4 v_color;\n"
      "void main(){\n"
      "float radian = radians(30.0);\n"
      "float cos = cos(radian);\n"
      "float sin = sin(radian);\n"
      "  gl_position = a_mx * a_my * vec4(apos.x, apos.y, apos.z, 1.0);\n"
      "  vec3 normal = normalize((a_mx * a_my * a_normal).xyz);\n"
      "  float dot = max(dot(u_lightdirection, normal), 0.0);\n"
      "  vec3 reflectedlight = u_lightcolor * a_color.rgb * dot;\n"
      "  v_color = vec4(reflectedlight, a_color.a);\n"
      "}\n\0";

  （2）图像渲染

  ​ opengl es图像渲染中着色器涉及到内置变量如下，所谓内置变量就是不用声明可以直接赋值，主要是为了实现特定的功能。

​ 而本次渲染涉及到两个内建变量：gl_position和gl_fragcolor；

​ 其中，gl_position变量表示最终传入片元着色器片元化要使用的顶点位置坐标，取值范围为-1.0到1.0，点超过该范围将自动被裁剪。初始化代码如下：

gl_position = a_mx * a_my * vec4(apos.x, apos.y, apos.z, 1.0);

​a_my为y轴旋转矩阵，获取到旋转角度后初始化旋转矩阵；a_mx为x轴旋转矩阵，apos为绘制多面体点矩阵；

这些值的初始化通过gluniformmatrix4fv函数实现：

    mxgl_apicall void gl_apientry gluniformmatrix4fv(glint location, glsizei count, glboolean transpose, const glfloat *value)

其中参数的含义如下：

​ gl_fragcolor变量用于确定图形的颜色，可通过设置不同片段着色器的颜色，实现立体效果。

        片段着色器实现如下：

char fragmentshader[] =
    "precision mediump float;\n"
    "varying vec4 v_color;\n"
    "void main () {\n"
    "   gl_fragcolor = v_color;\n"
    "}\n\0";

       三棱锥核心绘制代码如下：

 void tetrahedron::update(float anglex, float angley)
 {
      angley_ = angley;
      anglex_ = anglex;
      glclearcolor(1.0f, 1.0f, 1.0f, 1.0f);
      glclear(gl_color_buffer_bit);
      gluseprogram(mprogramhandle);

      unsigned int aposlocation = glgetattriblocation(mprogramhandle, "apos");
      unsigned int a_color = glgetattriblocation(mprogramhandle, "a_color");
      unsigned int a_normal = glgetattriblocation(mprogramhandle, "a_normal");
      unsigned int u_lightcolor = glgetuniformlocation(mprogramhandle, "u_lightcolor");
      unsigned int u_lightdirection = glgetuniformlocation(mprogramhandle, "u_lightdirection");
      unsigned int mx = glgetuniformlocation(mprogramhandle, "a_mx");
      unsigned int my = glgetuniformlocation(mprogramhandle, "a_my");

     /**
     y轴旋转度
     **/
     float radiany = angley * pi /180.0;
     float cosy = cosf(radiany);
     float siny = sinf(radiany);
     float myarr[] = {
         cosy,0,-siny,0,  0,1,0,0,  siny,0,cosy,0,  0,0,0,1
    };
     gluniformmatrix4fv(my, 1,false, myarr);

     /**
     x轴旋转度
     **/
     float radianx = anglex * pi /180.0;
     float cosx = cosf(radianx);
     float sinx = sinf(radianx);
     float mxarr[] = {
         1,0,0,0,  0,cosx,-sinx,0,  0,sinx,cosx,0,  0,0,0,1
    };
     gluniformmatrix4fv(mx, 1,false, mxarr);

     /**
      给平行光传入颜色和方向数据，rgb(1,1,1),单位向量(x,y,z)
      **/
     gluniform3f(u_lightcolor, 1.0, 1.0, 1.0);
     // 保证向量(x,y,z)的长度为1，即单位向量
     float x = 1.0/sqrt(15), y = 2.0/sqrt(15), z = 3.0/sqrt(15);
     gluniform3f(u_lightdirection, x,-y,z);

     /**
      创建顶点位置数据数组data，原点到各顶点的距离都为1
     **/
     float data[] = {
         -0.75, -0.50, -0.43, 0.75, -0.50, -0.43, 0.00, -0.50, 0.87,
         0.75, -0.50, -0.43, 0.00, -0.50, 0.87, 0.00, 1.00, 0.00,
         0.00, -0.50, 0.87, 0.00, 1.00, 0.00, -0.75, -0.50, -0.43,
         0.00, 1.00, 0.00, -0.75, -0.50, -0.43, 0.75, -0.50, -0.43,
     };

     /**
      创建顶点颜色数组colordata
      **/
     float colordata[] = {
         1,0,0, 1,0,0, 1,0,0,//红色——面1
         1,0,0, 1,0,0, 1,0,0,//红色——面2
         1,0,0, 1,0,0, 1,0,0,//红色——面3
         1,0,0, 1,0,0, 1,0,0 //红色——面4
     };

     /**
      顶点法向量数组normaldata
      **/
     float normaldata[] = {
         0.00, -1.00, 0.00,  0.00, -1.00, 0.00,  0.00, -1.00, 0.00,
         -0.83, -0.28, -0.48,  -0.83, -0.28, -0.48,  -0.83, -0.28, -0.48,
         -0.83, 0.28, 0.48,  -0.83, 0.28, 0.48,  -0.83, 0.28, 0.48,
         0.00, -0.28, 0.96,  0.00, -0.28, 0.96,  0.00, -0.28, 0.96,
     };

     /**
      创建缓冲区buffer，传入顶点位置数据data
      **/
     unsigned int buffer;
     glgenbuffers(1, &buffer);
     glbindbuffer(gl_array_buffer, buffer);
     glbufferdata(gl_array_buffer, sizeof(data), data, gl_static_draw);
     glvertexattribpointer(aposlocation, 3, gl_float, gl_false, 0, 0);
     glenablevertexattribarray(aposlocation);

     unsigned int normalbuffer;
     glgenbuffers(1, &normalbuffer);
     glbindbuffer(gl_array_buffer, normalbuffer);
     glbufferdata(gl_array_buffer, sizeof(normaldata), normaldata, gl_static_draw);
     glvertexattribpointer(a_normal, 3, gl_float, gl_false, 0, 0);
     glenablevertexattribarray(a_normal);

     /**
      创建缓冲区colorbuffer，传入顶点颜色数据colordata
      **/
     unsigned int colorbuffer;
     glgenbuffers(1, &colorbuffer);
     glbindbuffer(gl_array_buffer, colorbuffer);
     glbufferdata(gl_array_buffer, sizeof(colordata), colordata, gl_static_draw);
     glvertexattribpointer(a_color, 3, gl_float, gl_false, 0, 0);
     glenablevertexattribarray(a_color);

     /* 执行绘制命令 */
     gldrawarrays(gl_triangles, 0, 12);
 }

5、napi接口定义

接口定义为固定写法，在napi_property_descriptor desc[]中，我们需要使用declare_napi_function宏，以add函数为例，将函数名字符串"add"与具体的实现方法napi_value add(napi_env env, napi_callback_info info)进行关联，即declare_napi_function("add", add)最终添加到desc[]。如下所示，其中updateangle对应的是native c++的接口，其应用端的接口对应为updateangle，napi通过napi_define_properties接口将napi_property_descriptor结构体中的2个接口绑定在一起，并通过exports变量对外导出，使应用层可以调用updateangle和getcontext方法。

/*
 * function for module exports
 */
extern_c_start
static napi_value init(napi_env env, napi_value exports)
{
    loge("init");
    napi_property_descriptor desc[] = {
        declare_napi_function("getcontext", napimanager::getcontext),
        declare_napi_function("updateangle", appnapi::updateangle),
    };

    napi_call(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));

    bool ret = napimanager::getinstance()->export(env, exports);
    if (!ret) {
        loge("init failed");
    }

    return exports;
}
extern_c_end

6、napi接口实现

​ tetrahedron::updateangle：传入anglex和angley两个参数，分别为为绕x，y轴的旋转角度；作为参数调用tetrahedron::updateangle(float anglex, float angley)重新渲染，具体代码如下：

napi_value appnapi::updateangle(napi_env env, napi_callback_info info){
    loge("tetrahedron updateangle");
    size_t requireargc = 2;
    size_t argc = 2;
    int speed = 3;
    napi_value args[2] = {nullptr};

    napi_get_cb_info(env, info, &argc, args , nullptr, nullptr);

    napi_valuetype valuetype0;
    napi_typeof(env, args[0], &valuetype0);

    napi_valuetype valuetype1;
    napi_typeof(env, args[1], &valuetype1);

    double offsetx;
    napi_get_value_double(env, args[0], &offsetx);

    double offsety;
    napi_get_value_double(env, args[1], &offsety);

    /* 处理offsetx偏移角度 */
    float tetrahedron_anglex = tetrahedron_->getanglex();
    float tetrahedron_angley = tetrahedron_->getangley();

    /* 上下滑动绕x轴 */
    if(offsety < 0){
        tetrahedron_anglex = tetrahedron_anglex + speed;
    }
    else{
        tetrahedron_anglex = tetrahedron_anglex - speed;
    }

    /* 左右滑动绕y轴 */
    if(offsetx < 0){
        triangles_angley = triangles_angley + speed;
    }
    else{
        triangles_angley = triangles_angley - speed;
    }

    tetrahedron_angley = normalize(tetrahedron_angley);
    tetrahedron_anglex = normalize(tetrahedron_anglex);
    tetrahedron_->update(tetrahedron_anglex, tetrahedron_angley);

    /* 创建一个数组 */
    napi_value ret;
    napi_create_array(env, &ret);

    /* 设置数组并返回 */
    napi_value num;
    napi_create_int32(env, tetrahedron_anglex, &num);
    napi_set_element(env, ret, 0, num);
    napi_create_int32(env, tetrahedron_angley, &num);
    napi_set_element(env, ret, 1, num);

    return ret;
}

​ getcontext：得到渲染所xcomponent的上下文context，以便后续绑定xcomponentid渲染，具体代码如下：

napi_value napimanager::getcontext(napi_env env, napi_callback_info info)
{
    napi_status status;
    napi_value exports;
    size_t argc = 1;
    napi_value args[1];
    napi_call(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));

    if (argc != 1) {
        napi_throw_type_error(env, null, "wrong number of arguments");
        return nullptr;
    }

    napi_valuetype valuetype;
    status = napi_typeof(env, args[0], &valuetype);
    if (status != napi_ok) {
        return nullptr;
    }
    if (valuetype != napi_number) {
        napi_throw_type_error(env, null, "wrong arguments");
        return nullptr;
    }

    int64_t value;
    napi_call(env, napi_get_value_int64(env, args[0], &value));
    napi_call(env, napi_create_object(env, &exports));

    switch (value) {
        case int64_t(contexttype::app_lifecycle):
            {
                /* appinit 对应 app.ets中的应用生命周期 oncreate, onshow, onhide, ondestroy */
                logd("getcontext app_lifecycle");
                /* register app lifecycle */
                napi_property_descriptor desc[] = {
                    declare_napi_function("oncreate", napimanager::napioncreate),
                    declare_napi_function("onshow", napimanager::napionshow),
                    declare_napi_function("onhide", napimanager::napionhide),
                    declare_napi_function("ondestroy", napimanager::napiondestroy),
                };
                napi_call(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
            }

            break;
        case int64_t(contexttype::js_page_lifecycle):
            {
                /* js page */
                logd("getcontext js_page_lifecycle");
                napi_property_descriptor desc[] = {
                    declare_napi_function("onpageshow", napimanager::napionpageshow),
                    declare_napi_function("onpagehide", napimanager::napionpagehide),
                };
                napi_call(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
            }
            break;
        default:
            loge("unknown type");
    }
    return exports;
}

​ export：先拿到xcomponentid等信息后，通过napimanager得到context，再通过context得到处理3d绘画的appnapi类并进行相应输出处理。部分代码如下（具体请查看源码）：

bool napimanager::export(napi_env env, napi_value exports)
{
    napi_status status;
    napi_value exportinstance = nullptr;
    oh_nativexcomponent *nativexcomponent = nullptr;
    int32_t ret;
    char idstr[oh_xcomponent_id_len_max + 1] = { };
    uint64_t idsize = oh_xcomponent_id_len_max + 1;

    status = napi_get_named_property(env, exports, oh_native_xcomponent_obj, &exportinstance);
    if (status != napi_ok) {
        return false;
    }

    status = napi_unwrap(env, exportinstance, reinterpret_cast<void**>(&nativexcomponent));
    if (status != napi_ok) {
        return false;
    }

    ret = oh_nativexcomponent_getxcomponentid(nativexcomponent, idstr, &idsize);
    if (ret != oh_nativexcomponent_result_success) {
        return false;
    }

    std::string id(idstr);
    auto context = napimanager::getinstance();
    if (context) {
        context->setnativexcomponent(id, nativexcomponent);
        auto app = context->getapp(id);
        app->setnativexcomponent(nativexcomponent);
        app->export(env, exports);
        return true;
    }

    return false;
}

7、arkts接口定义

（1）修改 index.d.ts 用于对外提供方法、说明（命名为tetrahedron_napi.d.ts）。

//传入x，y偏移量并返回x，y旋转角
export const updateangle:(offsetx:number,offsety:number)=>array;

（2）在同目录下的 oh-package.json5 文件中将 tetrahedron_napi.d.ts 与cpp文件关联起来。

{
  "name": "libtetrahedron_napi.so",
  "types": "./tetrahedron_napi.d.ts",
  "version": "1.0.0",
  "description": "please describe the basic information."
}

（3）修改项目的oh-package.json5文件，添加动态库。

{
  "license": "",
  "devdependencies": {
    "@types/libtetrahedron_napi.so": "file:./src/main/cpp/type/libentry"
  },
  "author": "",
  "name": "entry",
  "description": "please describe the basic information.",
  "main": "",
  "version": "1.0.0",
  "dependencies": {}
}

8、cmake规则配置

entry/src/main/cpp/cmakelists.txt是cmake规则文件。

project：用于设置项目(project)的名称。

set(cmake_cxx_standard 11)：设置c++标准。

include_directories：用于包含头文件。

add_library：编译产生链接库。

target_link_libraries：指定链接给定目标和/或其依赖项时要使用的库或标志，在public字段后的库会被链接到tetrahedron_napi中。

# the minimum version of cmake.
cmake_minimum_required(version 3.4.1)

project(tetrahedronhap)

set(native_root_path ${cmake_current_source_dir})

include_directories(${native_root_path}
                    ${native_root_path}/include
                    ${native_root_path}/include/util)

add_library(triangles_napi shared
            module.cpp
            app_napi.cpp
            tetrahedron.cpp
            napi_manager.cpp
            napi_util.cpp)


target_link_libraries(tetrahedron_napi public egl)
target_link_libraries(tetrahedron_napi public glesv3)
target_link_libraries(tetrahedron_napi public hilog_ndk.z)
target_link_libraries(tetrahedron_napi public ace_ndk.z)
target_link_libraries(tetrahedron_napi public ace_napi.z)
target_link_libraries(tetrahedron_napi public libc++.a)
target_link_libraries(tetrahedron_napi public z)
target_link_libraries(tetrahedron_napi public uv)
target_link_libraries(tetrahedron_napi public libace_napi.z.so)

9、arkts实现

界面实现部分代码如下（具体请参考源码）,其中：libraryname参数对应先前设置的模块名：tetrahedron_napi

import hilog from '@ohos.hilog';
import tetrahedron_napi from 'libtetrahedron_napi.so'

@entry
@component
struct index {
  private xcomponentcontext = null;
  private xcomponentid = 'tetrahedron';
  private offset_x: number = 0.000;
  private offset_y: number = 0.000;
  private index: number = 0;
  private type_: number = 5;
  private touchtypedown: number = 0;
  private touchtypeup: number = 1;
  private touchtypemove: number = 2;
  private touchtypecancel: number = 3;
  @state startvisible: visibility = visibility.visible;

  @state anglearray: array<number> = new array<number>();
  private panoption: pangestureoptions = new pangestureoptions({ direction: pandirection.all })
  @state offsetx: number = 0
  @state offsety: number = 0
  @state positionx: number = 0
  @state positiony: number = 0
  @state message: string = 'wu'

  async abouttoappear() {
  }

  build() {
    column() {
      text($r('app.string.entryability_desc'))
        .fontsize($r('app.float.head_font_24'))
        .lineheight($r('app.float.wh_value_33'))
        .fontfamily('harmonyheiti-bold')
        .fontweight(fontweight.bold)
        .fontcolor($r('app.color.font_color_182431'))
        .textoverflow({ overflow: textoverflow.ellipsis })
        .textalign(textalign.start)
        .margin({ top: $r('app.float.wh_value_13'), bottom: $r('app.float.wh_value_15') });

      text(this.anglearray[0]&this.anglearray[1]?'x轴旋转:'+this.anglearray[0].tostring() +'°\ny轴旋转:'+this.anglearray[1].tostring() + '°':'')
        .fontsize($r('app.float.head_font_24'))
        .lineheight($r('app.float.wh_value_33'))
        .fontfamily('harmonyheiti-bold')
        .fontweight(fontweight.bold)
        .fontcolor($r('app.color.font_color_182431'))
        .textoverflow({ overflow: textoverflow.ellipsis })
        .textalign(textalign.start)
        .margin({ top: $r('app.float.wh_value_13'), bottom: $r('app.float.wh_value_15') });

      stack({ aligncontent: alignment.center }) {
        xcomponent({ id: this.xcomponentid, type: 'surface', libraryname: 'tetrahedron_napi' })
          .onload((context) => {
            hilog.info(0x0000, 'xcomponent', 'onload')
            this.xcomponentcontext = context;
            globalthis.xcomponentcontext = this.xcomponentcontext;
            globalthis.xcomponentid = this.xcomponentid;
            globalthis.touchtypedown = this.touchtypedown;
            globalthis.touchtypeup = this.touchtypeup;
            globalthis.type_ = this.type_;
            globalthis.index = this.index;
            globalthis.touchtypemove = this.touchtypemove;
            globalthis.touchtypecancel = this.touchtypecancel;
            globalthis.offset_x = this.offset_x;
            globalthis.offset_y = this.offset_y;
          })
          .width($r('app.float.wh_value_362'))
          .height($r('app.float.wh_value_362'))
          .key('tetrahedron')
          .backgroundcolor('#00000000')
          .ondestroy(() => {
            globalthis.flag = false;
            hilog.info(0x0000, "xcomponent", 'ondestroy')
          })
      }
      .gesture(
        pangesture(this.panoption)
          .onactionstart((event: gestureevent) => {
            console.info('onactionstart');
          })
          .onactionupdate((event: gestureevent) => {
            this.anglearray = tetrahedron_napi.updateangle(event.offsetx, event.offsety);
            hilog.info(0x0000, "gesture", 'offset:' + event.offsetx + "," + event.offsety);
          })
          .onactionend(() => {
            this.positionx = this.offsetx;
            this.positiony = this.offsety;
            console.info('onactionend');
          })
      )
      .width('100%')
      .height('100%')
      .backgroundcolor('#00000000')
    }
  }
}

最后

有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？但是又不知道从哪里下手，而且学习时频繁踩坑，最终浪费大量时间。所以本人整理了一些比较合适的鸿蒙（harmonyos next）学习路径和一些资料的整理供小伙伴学习

点击领取→纯血鸿蒙next全套最新学习资料（安全链接，放心点击）

希望这一份鸿蒙学习资料能够给大家带来帮助，有需要的小伙伴自行领取，限时开源，先到先得~无套路领取！！

​

有了路线图，怎么能没有学习资料呢，小编也准备了一份联合鸿蒙官方发布笔记整理收纳的一套系统性的鸿蒙（openharmony ）学习手册（共计1236页）与鸿蒙（openharmony ）开发入门教学视频，内容包含：（arkts、arkui开发组件、stage模型、多端部署、分布式应用开发、音频、视频、webgl、openharmony多媒体技术、napi组件、openharmony内核、harmony南向开发、鸿蒙项目实战等等）鸿蒙（harmonyos next）…等技术知识点。

获取以上完整版高清学习路线，请点击→纯血版全套鸿蒙harmonyos学习资料

二、harmonyos next 最新全套视频教程

​

三、《鸿蒙 (openharmony)开发基础到实战手册》

openharmony北向、南向开发环境搭建

​

《鸿蒙开发基础》

• arkts语言
• 安装deveco studio
• 运用你的第一个arkts应用
• arkui声明式ui开发
• .……​

《鸿蒙开发进阶》

• stage模型入门
• 网络管理
• 数据管理
• 电话服务
• 分布式应用开发
• 通知与窗口管理
• 多媒体技术
• 安全技能
• 任务管理
• webgl
• 国际化开发
• 应用测试
• dfx面向未来设计
• 鸿蒙系统移植和裁剪定制
• ……

​

《鸿蒙进阶实战》

• arkts实践
• uiability应用
• 网络案例
• ……

​

四、大厂面试必问面试题

​

五、鸿蒙南向开发技术

​

六、鸿蒙app开发必备

​

七、鸿蒙生态应用开发白皮书v2.0pdf

​

完整鸿蒙harmonyos学习资料，请点击→纯血版全套鸿蒙harmonyos学习资料

总结
总的来说，华为鸿蒙不再兼容安卓，对中年程序员来说是一个挑战，也是一个机会。只有积极应对变化，不断学习和提升自己，他们才能在这个变革的时代中立于不败之地。