1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "core/components_ng/pattern/model/model_adapter_wrapper.h"
17 #include "core/components_ng/render/adapter/rosen_render_context.h"
18 #include "frameworks/core/common/container.h"
19
20 #include "graphics_task.h"
21 #include "ohos/graphics_manager.h"
22
23 #include "render_service_client/core/ui/rs_ui_director.h"
24 #include "render_service_client/core/ui/rs_ui_share_context.h"
25
26 namespace OHOS::Ace::NG {
27
SetHapInfo()28 Render3D::HapInfo ModelAdapterWrapper::SetHapInfo()
29 {
30 auto container = Container::Current();
31 if (container == nullptr) {
32 LOGE("modle 3d fail to get container");
33 return {};
34 }
35 std::string hapPath = container->GetHapPath();
36 Render3D::HapInfo hapInfo { hapPath, bundleName_, moduleName_ };
37 return hapInfo;
38 }
39
ModelAdapterWrapper(uint32_t key,Render3D::SurfaceType surfaceType,const std::string & bundleName,const std::string & moduleName)40 ModelAdapterWrapper::ModelAdapterWrapper(uint32_t key, Render3D::SurfaceType surfaceType,
41 const std::string& bundleName, const std::string& moduleName) : key_(key), surfaceType_(surfaceType),
42 bundleName_(bundleName), moduleName_(moduleName)
43 {
44 touchHandler_ = MakeRefPtr<ModelTouchHandler>();
45 touchHandler_->SetCameraEventCallback([weak = WeakClaim(this)]
46 (const Render3D::PointerEvent& event) {
47 auto adapter = weak.Upgrade();
48 CHECK_NULL_VOID(adapter);
49 adapter->HandleCameraMove(event);
50 });
51
52 #if MULTI_ECS_UPDATE_AT_ONCE
53 RefPtr<PipelineBase> pipeline = PipelineBase::GetCurrentContext();
54 CHECK_NULL_VOID(pipeline);
55 if (pipeline) {
56 Render3D::GraphicsManager::GetInstance().AttachContext(pipeline);
57 } else {
58 LOGE("MODEL_NG: pipeline context is null");
59 }
60 #endif
61 }
62
Deinit()63 void ModelAdapterWrapper::Deinit()
64 {
65 ACE_SCOPED_TRACE("ModelAdapterWrapper::Deinit");
66 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this)] {
67 ACE_SCOPED_TRACE("ModelAdapterWrapper::Deinit render");
68 auto adapter = weak.Upgrade();
69 CHECK_NULL_VOID(adapter);
70
71 CHECK_NULL_VOID(adapter->widgetAdapter_);
72 adapter->widgetAdapter_->DeInitEngine();
73
74 Render3D::GraphicsManager::GetInstance().UnRegister(adapter->GetKey());
75
76 auto& textureLayer = adapter->textureLayer_;
77 CHECK_NULL_VOID(textureLayer);
78 textureLayer->DestroyRenderTarget();
79 });
80 }
81
CreateTextureLayer()82 void ModelAdapterWrapper::CreateTextureLayer()
83 {
84 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this)] {
85 auto adapter = weak.Upgrade();
86 CHECK_NULL_VOID(adapter);
87
88 auto& gfxManager = Render3D::GraphicsManager::GetInstance();
89 const auto& key = adapter->GetKey();
90 gfxManager.Register(key);
91 adapter->textureLayer_ = std::make_unique<Render3D::TextureLayer>(key);
92 });
93 }
94
CreateWidgetAdapter()95 void ModelAdapterWrapper::CreateWidgetAdapter()
96 {
97 auto key = GetKey();
98 Render3D::HapInfo hapInfo = SetHapInfo();
99 // init engine in async manager sometimes crash on screen rotation
100 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), key, &hapInfo] {
101 auto adapter = weak.Upgrade();
102 CHECK_NULL_VOID(adapter);
103
104 adapter->widgetAdapter_ = std::make_shared<Render3D::WidgetAdapter>(key);
105 auto& gfxManager = Render3D::GraphicsManager::GetInstance();
106 auto&& engine = gfxManager.GetEngine(Render3D::EngineFactory::EngineType::LUME, adapter->GetKey(),
107 hapInfo);
108 adapter->widgetAdapter_->Initialize(std::move(engine));
109 });
110 }
111
OnAttachToFrameNode(const RefPtr<RenderContext> & context)112 void ModelAdapterWrapper::OnAttachToFrameNode(const RefPtr<RenderContext>& context)
113 {
114 CreateTextureLayer();
115 CreateWidgetAdapter();
116
117 #ifdef ENABLE_ROSEN_BACKEND
118 auto rsContext = DynamicCast<NG::RosenRenderContext>(context);
119 CHECK_NULL_VOID(rsContext);
120 auto rsNode = rsContext->GetRSNode();
121 CHECK_NULL_VOID(rsNode);
122 rsNode->SetFrameGravity(Rosen::Gravity::RESIZE);
123 #endif
124 }
125
OnDirtyLayoutWrapperSwap(float offsetX,float offsetY,float width,float height,float scale,bool recreateWindow)126 void ModelAdapterWrapper::OnDirtyLayoutWrapperSwap(float offsetX, float offsetY, float width, float height,
127 float scale, bool recreateWindow)
128 {
129 needsSyncPaint_ = true;
130 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), offsetX, offsetY,
131 width, height, scale, recreateWindow] {
132 auto adapter = weak.Upgrade();
133 CHECK_NULL_VOID(adapter);
134 CHECK_NULL_VOID(adapter->textureLayer_);
135 CHECK_NULL_VOID(adapter->widgetAdapter_);
136
137 adapter->textureLayer_->OnWindowChange(offsetX, offsetY, width, height, scale, recreateWindow,
138 adapter->surfaceType_);
139 adapter->widgetAdapter_->OnWindowChange(adapter->textureLayer_->GetTextureInfo());
140 });
141 }
142
OnDirtyLayoutWrapperSwap(const Render3D::WindowChangeInfo & windowChangeInfo)143 void ModelAdapterWrapper::OnDirtyLayoutWrapperSwap(const Render3D::WindowChangeInfo& windowChangeInfo)
144 {
145 needsSyncPaint_ = true;
146 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), &windowChangeInfo] {
147 auto adapter = weak.Upgrade();
148 CHECK_NULL_VOID(adapter);
149 CHECK_NULL_VOID(adapter->textureLayer_);
150 CHECK_NULL_VOID(adapter->widgetAdapter_);
151
152 adapter->textureLayer_->OnWindowChange(windowChangeInfo);
153 adapter->widgetAdapter_->OnWindowChange(adapter->textureLayer_->GetTextureInfo());
154 });
155 }
156
OnRebuildFrame(RefPtr<RenderContext> & context)157 void ModelAdapterWrapper::OnRebuildFrame(RefPtr<RenderContext>& context)
158 {
159 CHECK_NULL_VOID(textureLayer_);
160
161 #ifdef ENABLE_ROSEN_BACKEND
162 CHECK_NULL_VOID(context);
163 auto rsNode = DynamicCast<NG::RosenRenderContext>(context)->GetRSNode();
164 textureLayer_->SetParent(rsNode);
165 #endif
166 }
167
OnPaint3D(const RefPtr<ModelPaintProperty> & modelPaintProperty)168 void ModelAdapterWrapper::OnPaint3D(const RefPtr<ModelPaintProperty>& modelPaintProperty)
169 {
170 CHECK_NULL_VOID(modelPaintProperty);
171
172 if (modelPaintProperty->NeedsModelSourceSetup()) {
173 UpdateScene(modelPaintProperty);
174 }
175
176 if (modelPaintProperty->NeedsModelBackgroundSetup()) {
177 UpdateEnviroment(modelPaintProperty);
178 }
179
180 if (modelPaintProperty->NeedsCameraSetup()) {
181 UpdateCamera(modelPaintProperty);
182 }
183
184 if (modelPaintProperty->NeedsLightsSetup()) {
185 UpdateLights(modelPaintProperty);
186 }
187
188 if (modelPaintProperty->NeedsAnimationsSetup()) {
189 UpdateGLTFAnimations(modelPaintProperty);
190 }
191
192 if (modelPaintProperty->NeedsGeometriesSetup()) {
193 UpdateGeometries(modelPaintProperty);
194 }
195
196 if (modelPaintProperty->NeedsCustomRenderSetup()) {
197 UpdateCustomRender(modelPaintProperty);
198 }
199
200 if (modelPaintProperty->NeedsShaderPathSetup()) {
201 UpdateShaderPath(modelPaintProperty);
202 }
203
204 if (modelPaintProperty->NeedsImageTexturePathsSetup()) {
205 UpdateImageTexturePaths(modelPaintProperty);
206 }
207
208 if (modelPaintProperty->NeedsShaderInputBufferSetup()) {
209 UpdateShaderInputBuffers(modelPaintProperty);
210 }
211
212 DrawFrame();
213 }
214
OnPaint3DSceneTexture(SkCanvas * skCanvas)215 void ModelAdapterWrapper::OnPaint3DSceneTexture(SkCanvas* skCanvas)
216 {
217 textureLayer_->OnDraw(skCanvas);
218 }
219
DrawFrame()220 void ModelAdapterWrapper::DrawFrame()
221 {
222 ACE_FUNCTION_TRACE();
223 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this)] {
224 auto adapter = weak.Upgrade();
225 CHECK_NULL_VOID(adapter);
226 CHECK_NULL_VOID(adapter->widgetAdapter_);
227
228 adapter->needsRepaint_ = adapter->widgetAdapter_->NeedsRepaint();
229 });
230
231 const auto& msg = [weak = WeakClaim(this)] {
232 auto adapter = weak.Upgrade();
233 CHECK_NULL_VOID(adapter);
234 CHECK_NULL_VOID(adapter->widgetAdapter_);
235
236 adapter->widgetAdapter_->DrawFrame();
237 };
238
239 if (needsSyncPaint_) {
240 #if !defined (MULTI_ECS_UPDATE_AT_ONCE) || (MULTI_ECS_UPDATE_AT_ONCE == 0)
241 needsSyncPaint_ = false;
242 #endif
243 Render3D::GraphicsTask::GetInstance().PushSyncMessage(msg);
244 } else {
245 Render3D::GraphicsTask::GetInstance().PushAsyncMessage(msg);
246 }
247 }
248
OnPaintFinish()249 void ModelAdapterWrapper::OnPaintFinish()
250 {
251 if (callback_) {
252 callback_();
253 }
254 }
255
UnloadSceneAndBackground()256 void ModelAdapterWrapper::UnloadSceneAndBackground()
257 {
258 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this)] {
259 auto adapter = weak.Upgrade();
260 CHECK_NULL_VOID(adapter);
261 CHECK_NULL_VOID(adapter->widgetAdapter_);
262
263 adapter->widgetAdapter_->UnloadSceneModel();
264 adapter->widgetAdapter_->UnloadEnvModel();
265 });
266 }
267
NeedsRepaint()268 bool ModelAdapterWrapper::NeedsRepaint()
269 {
270 return needsRepaint_;
271 }
272
~ModelAdapterWrapper()273 ModelAdapterWrapper::~ModelAdapterWrapper()
274 {
275 // Destroy resource explicitly before destruct
276 }
277
GetKey()278 uint32_t ModelAdapterWrapper::GetKey()
279 {
280 return key_;
281 }
282
SetPaintFinishCallback(PaintFinishCallback callback)283 void ModelAdapterWrapper::SetPaintFinishCallback(PaintFinishCallback callback)
284 {
285 callback_ = std::move(callback);
286 }
287
HandleTouchEvent(const TouchEventInfo & info,const RefPtr<ModelPaintProperty> & modelPaintProperty)288 bool ModelAdapterWrapper::HandleTouchEvent(const TouchEventInfo& info,
289 const RefPtr<ModelPaintProperty>& modelPaintProperty)
290 {
291 CHECK_NULL_RETURN(touchHandler_, false);
292 CHECK_NULL_RETURN(textureLayer_, false);
293 const auto& textureInfo = textureLayer_->GetTextureInfo();
294 auto width = textureInfo.width_;
295 auto height = textureInfo.height_;
296 auto cameraState = modelPaintProperty->GetModelCameraMove().value_or(true);
297 touchHandler_->HandleCameraEvents(cameraState);
298 return touchHandler_->HandleTouchEvent(info, width, height);
299 }
300
UpdateScene(const RefPtr<ModelPaintProperty> & modelPaintProperty)301 void ModelAdapterWrapper::UpdateScene(const RefPtr<ModelPaintProperty>& modelPaintProperty)
302 {
303 if (!modelPaintProperty->GetModelSource().has_value()) {
304 LOGW("UpdateScene invalid model source");
305 return;
306 }
307
308 auto& modelSource = modelPaintProperty->GetModelSource().value();
309 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), modelSource] {
310 auto adapter = weak.Upgrade();
311 CHECK_NULL_VOID(adapter);
312 CHECK_NULL_VOID(adapter->widgetAdapter_);
313
314 adapter->widgetAdapter_->LoadSceneModel(modelSource.c_str());
315 });
316 }
317
UpdateEnviroment(const RefPtr<ModelPaintProperty> & modelPaintProperty)318 void ModelAdapterWrapper::UpdateEnviroment(const RefPtr<ModelPaintProperty>& modelPaintProperty)
319 {
320 if (!modelPaintProperty->GetModelBackground().has_value()) {
321 LOGW("UpdateEnviroment invalid model background");
322 return;
323 }
324
325 Render3D::BackgroundType backgroundType = modelPaintProperty->GetModelTransparent().value_or(false) ?
326 Render3D::BackgroundType::TRANSPARENT : Render3D::BackgroundType::CUBE_MAP;
327 auto& backgroundPath = modelPaintProperty->GetModelBackground().value();
328
329 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), &backgroundPath,
330 &backgroundType] {
331 auto adapter = weak.Upgrade();
332 CHECK_NULL_VOID(adapter);
333 CHECK_NULL_VOID(adapter->widgetAdapter_);
334
335 adapter->widgetAdapter_->LoadEnvModel(backgroundPath, backgroundType);
336 });
337 }
338
HandleCameraMove(const Render3D::PointerEvent & event)339 void ModelAdapterWrapper::HandleCameraMove(const Render3D::PointerEvent& event)
340 {
341 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), &event] {
342 auto adapter = weak.Upgrade();
343 CHECK_NULL_VOID(adapter);
344 CHECK_NULL_VOID(adapter->widgetAdapter_);
345
346 adapter->widgetAdapter_->OnTouchEvent(event);
347 });
348 }
349
ExtractCameraProperty(const RefPtr<ModelPaintProperty> & modelPaintProperty,CameraProperty & camera)350 void ExtractCameraProperty(const RefPtr<ModelPaintProperty>& modelPaintProperty,
351 CameraProperty& camera)
352 {
353 if (modelPaintProperty->GetCameraPosition().has_value()) {
354 auto& v = modelPaintProperty->GetCameraPosition().value();
355 camera.position_.SetPosition(Render3D::Vec3 { v.GetX(), v.GetY(), v.GetZ() });
356 }
357
358 if (modelPaintProperty->GetCameraDistance().has_value()) {
359 const auto& v = modelPaintProperty->GetCameraDistance().value().GetValue();
360 camera.position_.SetDistance(v);
361 }
362
363 if (modelPaintProperty->GetCameraIsAngular().has_value()) {
364 auto& v = modelPaintProperty->GetCameraIsAngular().value();
365 camera.position_.SetIsAngular(v);
366 }
367
368 if (modelPaintProperty->GetCameraLookAt().has_value()) {
369 const auto& v = modelPaintProperty->GetCameraLookAt().value();
370 camera.lookAt_.SetX(v.GetX());
371 camera.lookAt_.SetY(v.GetY());
372 camera.lookAt_.SetZ(v.GetZ());
373 }
374
375 if (modelPaintProperty->GetCameraUp().has_value()) {
376 const auto& v = modelPaintProperty->GetCameraUp().value();
377 camera.up_.SetX(v.GetX());
378 camera.up_.SetY(v.GetY());
379 camera.up_.SetZ(v.GetZ());
380 }
381
382 if (modelPaintProperty->GetCameraUp().has_value()) {
383 const auto& v = modelPaintProperty->GetCameraUp().value();
384 camera.up_.SetX(v.GetX());
385 camera.up_.SetY(v.GetY());
386 camera.up_.SetZ(v.GetZ());
387 }
388
389 if (modelPaintProperty->GetCameraRotation().has_value()) {
390 const auto& v = modelPaintProperty->GetCameraRotation().value();
391 camera.rotation_.SetX(v.GetX());
392 camera.rotation_.SetY(v.GetY());
393 camera.rotation_.SetZ(v.GetZ());
394 camera.rotation_.SetW(v.GetW());
395 }
396
397 if (modelPaintProperty->GetCameraZNear().has_value()) {
398 camera.near_ = modelPaintProperty->GetCameraZNear().value();
399 }
400
401 if (modelPaintProperty->GetCameraZFar().has_value()) {
402 camera.far_ = modelPaintProperty->GetCameraZFar().value();
403 }
404
405 if (modelPaintProperty->GetCameraFOV().has_value()) {
406 camera.fov_ = modelPaintProperty->GetCameraFOV().value();
407 }
408 }
409
UpdateCamera(const RefPtr<ModelPaintProperty> & modelPaintProperty)410 void ModelAdapterWrapper::UpdateCamera(const RefPtr<ModelPaintProperty>& modelPaintProperty)
411 {
412 CameraProperty camera;
413 ExtractCameraProperty(modelPaintProperty, camera);
414 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), &camera] {
415 auto adapter = weak.Upgrade();
416 CHECK_NULL_VOID(adapter);
417 CHECK_NULL_VOID(adapter->widgetAdapter_);
418
419 adapter->widgetAdapter_->SetupCameraTransform(camera.position_, camera.lookAt_, camera.up_,
420 camera.rotation_);
421 adapter->widgetAdapter_->SetupCameraViewProjection(camera.near_, camera.far_, camera.fov_);
422 });
423 }
424
ExtractLightsProperty(const RefPtr<ModelPaintProperty> & modelPaintProperty,std::vector<std::shared_ptr<Render3D::Light>> & lights)425 void ExtractLightsProperty(const RefPtr<ModelPaintProperty>& modelPaintProperty,
426 std::vector<std::shared_ptr<Render3D::Light>>& lights)
427 {
428 auto& propLights = modelPaintProperty->GetModelLights().value();
429 for (auto& light : propLights) {
430 const auto& color = light->GetLightColor();
431 const auto& rotation = light->GetRotation();
432 const auto& position = light->GetPosition();
433
434 Render3D::Position lightPosition;
435 lightPosition.SetPosition(Render3D::Vec3(position.GetX(), position.GetY(), position.GetZ()));
436 lightPosition.SetDistance(position.GetDistance().GetValue());
437 lightPosition.SetIsAngular(position.GetIsAngular());
438 Render3D::LightType lightType;
439 switch (light->GetLightType()) {
440 case ModelLightType::INVALID_LIGHT:
441 lightType = Render3D::LightType::INVALID;
442 break;
443 case ModelLightType::DIRECTIONAL_LIGHT:
444 lightType = Render3D::LightType::DIRECTIONAL;
445 break;
446 case ModelLightType::POINT_LIGHT:
447 lightType = Render3D::LightType::POINT;
448 break;
449 case ModelLightType::SPOT_LIGHT:
450 lightType = Render3D::LightType::SPOT;
451 break;
452 default:
453 LOGW("invalid light type");
454 }
455
456 lights.push_back(std::make_shared<Render3D::Light>(lightType, Render3D::Vec3(
457 color.GetX(), color.GetY(), color.GetZ()), light->GetLightIntensity().GetValue(),
458 light->GetLightShadow(), lightPosition, Render3D::Quaternion(rotation.GetX(),
459 rotation.GetY(), rotation.GetZ(), rotation.GetW())));
460 }
461 }
462
UpdateLights(const RefPtr<ModelPaintProperty> & modelPaintProperty)463 void ModelAdapterWrapper::UpdateLights(const RefPtr<ModelPaintProperty>& modelPaintProperty)
464 {
465 if (!modelPaintProperty->GetModelLights().has_value()) {
466 LOGW("MODEL_NG: UpdateLights invalid lights");
467 return;
468 }
469
470 std::vector<std::shared_ptr<Render3D::Light>> lights;
471 ExtractLightsProperty(modelPaintProperty, lights);
472
473 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), &lights] {
474 auto adapter = weak.Upgrade();
475 CHECK_NULL_VOID(adapter);
476 CHECK_NULL_VOID(adapter->widgetAdapter_);
477
478 adapter->widgetAdapter_->UpdateLights(lights);
479 });
480 }
481
UpdateGLTFAnimations(const RefPtr<ModelPaintProperty> & modelPaintProperty)482 void ModelAdapterWrapper::UpdateGLTFAnimations(const RefPtr<ModelPaintProperty>& modelPaintProperty)
483 {
484 if (!modelPaintProperty->GetModelAnimations().has_value()) {
485 LOGW("UpdateGLTFAnimations invalid animation");
486 return;
487 }
488
489 auto& animations = modelPaintProperty->GetModelAnimations().value();
490 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), &animations] {
491 auto adapter = weak.Upgrade();
492 CHECK_NULL_VOID(adapter);
493 CHECK_NULL_VOID(adapter->widgetAdapter_);
494
495 adapter->widgetAdapter_->UpdateGLTFAnimations(animations);
496 });
497 }
498
UpdateGeometries(const RefPtr<ModelPaintProperty> & modelPaintProperty)499 void ModelAdapterWrapper::UpdateGeometries(const RefPtr<ModelPaintProperty>& modelPaintProperty)
500 {
501 if (!modelPaintProperty->GetModelGeometries().has_value()) {
502 LOGW("UpdateGeometries invalid geometries");
503 return;
504 }
505
506 auto& geometries = modelPaintProperty->GetModelGeometries().value();
507
508 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), &geometries] {
509 auto adapter = weak.Upgrade();
510 CHECK_NULL_VOID(adapter);
511 CHECK_NULL_VOID(adapter->widgetAdapter_);
512
513 adapter->widgetAdapter_->UpdateGeometries(geometries);
514 });
515 }
516
UpdateCustomRender(const RefPtr<ModelPaintProperty> & modelPaintProperty)517 void ModelAdapterWrapper::UpdateCustomRender(const RefPtr<ModelPaintProperty>& modelPaintProperty)
518 {
519 if (!modelPaintProperty->GetModelCustomRender().has_value()) {
520 LOGW("UpdateCustomRender invalid custom render");
521 return;
522 }
523
524 auto& customRender = modelPaintProperty->GetModelCustomRender().value();
525 if (!customRender) {
526 return;
527 }
528
529 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), &customRender] {
530 auto adapter = weak.Upgrade();
531 CHECK_NULL_VOID(adapter);
532 CHECK_NULL_VOID(adapter->widgetAdapter_);
533
534 adapter->widgetAdapter_->UpdateCustomRender(customRender);
535 });
536 }
537
UpdateShaderPath(const RefPtr<ModelPaintProperty> & modelPaintProperty)538 void ModelAdapterWrapper::UpdateShaderPath(const RefPtr<ModelPaintProperty>& modelPaintProperty)
539 {
540 if (!modelPaintProperty->GetShaderPath().has_value()) {
541 LOGW("UpdateShaderPath invalid shader path");
542 return;
543 }
544
545 auto& shaderPath = modelPaintProperty->GetShaderPath().value();
546
547 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), &shaderPath] {
548 auto adapter = weak.Upgrade();
549 CHECK_NULL_VOID(adapter);
550 CHECK_NULL_VOID(adapter->widgetAdapter_);
551
552 adapter->widgetAdapter_->UpdateShaderPath(shaderPath);
553 });
554 }
555
UpdateImageTexturePaths(const RefPtr<ModelPaintProperty> & modelPaintProperty)556 void ModelAdapterWrapper::UpdateImageTexturePaths(const RefPtr<ModelPaintProperty>& modelPaintProperty)
557 {
558 if (!modelPaintProperty->GetModelImageTexturePaths().has_value()) {
559 LOGW("UpdateImageTexturePaths invalid image texture");
560 return;
561 }
562
563 auto& imageTexture = modelPaintProperty->GetModelImageTexturePaths().value();
564
565 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), &imageTexture] {
566 auto adapter = weak.Upgrade();
567 CHECK_NULL_VOID(adapter);
568 CHECK_NULL_VOID(adapter->widgetAdapter_);
569
570 adapter->widgetAdapter_->UpdateImageTexturePaths(imageTexture);
571 });
572 }
573
UpdateShaderInputBuffers(const RefPtr<ModelPaintProperty> & modelPaintProperty)574 void ModelAdapterWrapper::UpdateShaderInputBuffers(const RefPtr<ModelPaintProperty>& modelPaintProperty)
575 {
576 if (!modelPaintProperty->GetModelShaderInputBuffer().has_value()) {
577 LOGW("UpdateShaderInputBuffers invalid shader input buffer");
578 return;
579 }
580
581 auto& shaderInputBuffer = modelPaintProperty->GetModelShaderInputBuffer().value();
582
583 Render3D::GraphicsTask::GetInstance().PushSyncMessage([weak = WeakClaim(this), &shaderInputBuffer] {
584 auto adapter = weak.Upgrade();
585 CHECK_NULL_VOID(adapter);
586 CHECK_NULL_VOID(adapter->widgetAdapter_);
587
588 adapter->widgetAdapter_->UpdateShaderInputBuffer(shaderInputBuffer);
589 });
590 }
591 } // namespace OHOS::Ace::NG
592