1/*
2 * Copyright (C) 2023 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 "widget_adapter.h"
17
18#include <window.h>
19
20#include "3d_widget_adapter_log.h"
21#include "graphics_manager.h"
22#include "widget_trace.h"
23
24namespace OHOS::Render3D {
25#ifdef CHECK_NULL_PTR
26#undef CHECK_NULL_PTR
27#endif
28#define CHECK_NULL_PTR(ptr) \
29do { \
30    if (!(ptr)) { \
31        WIDGET_LOGE("%s engine not ready", __func__); \
32        return false; \
33    } \
34} while (false)
35
36WidgetAdapter::WidgetAdapter(uint32_t key) : key_(key)
37{
38    WIDGET_LOGD("WidgetAdapter create key %d", key);
39}
40
41WidgetAdapter::~WidgetAdapter()
42{
43    WIDGET_LOGD("WidgetAdapter destroy key %d", key_);
44}
45
46bool WidgetAdapter::Initialize(std::unique_ptr<IEngine> engine)
47{
48    WIDGET_SCOPED_TRACE("WidgetAdapter::Initialze");
49    engine_ = std::move(engine);
50    CHECK_NULL_PTR(engine_);
51    engine_->InitializeScene(key_);
52    return true;
53}
54
55bool WidgetAdapter::SetupCameraTransform(
56    const OHOS::Render3D::Position& position, const OHOS::Render3D::Vec3& lookAt,
57    const OHOS::Render3D::Vec3& up, const OHOS::Render3D::Quaternion& rotation)
58{
59    CHECK_NULL_PTR(engine_);
60    engine_->SetupCameraTransform(position, lookAt, up, rotation);
61    return true;
62}
63
64bool WidgetAdapter::SetupCameraViewProjection(float zNear, float zFar, float fovDegrees)
65{
66    CHECK_NULL_PTR(engine_);
67    engine_->SetupCameraViewProjection(zNear, zFar, fovDegrees);
68    return true;
69}
70
71bool WidgetAdapter::UpdateLights(const std::vector<std::shared_ptr<OHOS::Render3D::Light>>& lights)
72{
73    CHECK_NULL_PTR(engine_);
74    engine_->UpdateLights(lights);
75    return true;
76}
77
78bool WidgetAdapter::OnTouchEvent(const PointerEvent& event)
79{
80    CHECK_NULL_PTR(engine_);
81    engine_->OnTouchEvent(event);
82    return true;
83}
84
85bool WidgetAdapter::DrawFrame()
86{
87    WIDGET_SCOPED_TRACE("WidgetAdpater::DrawFrame");
88    CHECK_NULL_PTR(engine_);
89#if MULTI_ECS_UPDATE_AT_ONCE
90    engine_->DeferDraw();
91#else
92    engine_->DrawFrame();
93#endif
94    return true;
95}
96
97bool WidgetAdapter::UpdateGeometries(const std::vector<std::shared_ptr<Geometry>>& shapes)
98{
99    CHECK_NULL_PTR(engine_);
100    engine_->UpdateGeometries(shapes);
101    return true;
102}
103
104bool WidgetAdapter::UpdateGLTFAnimations(const std::vector<std::shared_ptr<GLTFAnimation>>&
105    animations)
106{
107    CHECK_NULL_PTR(engine_);
108    engine_->UpdateGLTFAnimations(animations);
109    return true;
110}
111
112
113bool WidgetAdapter::UpdateCustomRender(const std::shared_ptr<CustomRenderDescriptor>&
114    customRenders)
115{
116    CHECK_NULL_PTR(engine_);
117    engine_->UpdateCustomRender(customRenders);
118    return true;
119}
120
121bool WidgetAdapter::UpdateShaderPath(const std::string& shaderPath)
122{
123    CHECK_NULL_PTR(engine_);
124    auto tempPath = const_cast<std::string&> (shaderPath);
125    auto index = tempPath.find_last_of("/");
126    auto strSize = tempPath.size();
127    if (index != std::string::npos && index != (strSize - 1)) {
128        auto fileName = tempPath.substr(index + 1);
129        auto suffixIndex = fileName.find_last_of(".");
130        if (suffixIndex != std::string::npos) {
131            tempPath = tempPath.substr(0, index);
132            auto dirIndex = tempPath.find_last_of("/");
133            tempPath = (dirIndex != std::string::npos) ? tempPath.substr(0, dirIndex) : tempPath;
134        }
135    }
136    auto shaderPathOut = const_cast<const std::string&> (tempPath);
137    engine_->UpdateShaderPath(shaderPathOut);
138    return true;
139}
140
141bool WidgetAdapter::UpdateImageTexturePaths(const std::vector<std::string>& imageTextures)
142{
143    CHECK_NULL_PTR(engine_);
144    engine_->UpdateImageTexturePaths(imageTextures);
145    return true;
146}
147
148bool WidgetAdapter::UpdateShaderInputBuffer(const std::shared_ptr<OHOS::Render3D::ShaderInputBuffer>&
149    shaderInputBuffer)
150{
151    CHECK_NULL_PTR(engine_);
152    engine_->UpdateShaderInputBuffer(shaderInputBuffer);
153    return true;
154}
155
156void WidgetAdapter::DeInitEngine()
157{
158    WIDGET_SCOPED_TRACE("WidgetAdapter::DeInitEngine");
159    if (engine_ == nullptr) {
160        return;
161    }
162    engine_->DeInitEngine();
163    engine_.reset();
164}
165
166bool WidgetAdapter::SetupCameraViewport(uint32_t width, uint32_t height)
167{
168    CHECK_NULL_PTR(engine_);
169    engine_->SetupCameraViewPort(width, height);
170    return true;
171}
172
173bool WidgetAdapter::OnWindowChange(const TextureInfo& textureInfo)
174{
175    CHECK_NULL_PTR(engine_);
176    engine_->OnWindowChange(textureInfo);
177    return true;
178}
179
180bool WidgetAdapter::LoadSceneModel(const std::string& scene)
181{
182    CHECK_NULL_PTR(engine_);
183    engine_->LoadSceneModel(scene);
184    return true;
185}
186
187bool WidgetAdapter::LoadEnvModel(const std::string& enviroment, BackgroundType type)
188{
189    CHECK_NULL_PTR(engine_);
190    engine_->LoadEnvModel(enviroment, type);
191    return true;
192}
193
194bool WidgetAdapter::UnloadSceneModel()
195{
196    CHECK_NULL_PTR(engine_);
197    engine_->UnloadSceneModel();
198    return true;
199}
200
201bool WidgetAdapter::UnloadEnvModel()
202{
203    CHECK_NULL_PTR(engine_);
204    engine_->UnloadSceneModel();
205    return true;
206}
207
208bool WidgetAdapter::NeedsRepaint()
209{
210    CHECK_NULL_PTR(engine_);
211    return engine_->NeedsRepaint();
212}
213} // namespace OHOS::Render3D
214