1 /*
2 * Copyright (c) 2024 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 "render_data_store_default_camera.h"
17
18 #include <cinttypes>
19 #include <cstddef>
20
21 #include <3d/render/default_material_constants.h>
22 #include <3d/render/intf_render_data_store_default_camera.h>
23 #include <base/containers/array_view.h>
24 #include <base/containers/fixed_string.h>
25
26 CORE3D_BEGIN_NAMESPACE()
27 using namespace BASE_NS;
28
RenderDataStoreDefaultCamera(const string_view name)29 RenderDataStoreDefaultCamera::RenderDataStoreDefaultCamera(const string_view name) : name_(name) {}
30
PostRender()31 void RenderDataStoreDefaultCamera::PostRender()
32 {
33 Clear();
34 }
35
Clear()36 void RenderDataStoreDefaultCamera::Clear()
37 {
38 cameras_.clear();
39 environments_.clear();
40
41 hasBlendEnvironments_ = false;
42 }
43
Ref()44 void RenderDataStoreDefaultCamera::Ref()
45 {
46 refcnt_.fetch_add(1, std::memory_order_relaxed);
47 }
48
Unref()49 void RenderDataStoreDefaultCamera::Unref()
50 {
51 if (std::atomic_fetch_sub_explicit(&refcnt_, 1, std::memory_order_release) == 1) {
52 std::atomic_thread_fence(std::memory_order_acquire);
53 delete this;
54 }
55 }
56
GetRefCount()57 int32_t RenderDataStoreDefaultCamera::GetRefCount()
58 {
59 return refcnt_;
60 }
61
AddCamera(const RenderCamera & camera)62 void RenderDataStoreDefaultCamera::AddCamera(const RenderCamera& camera)
63 {
64 if (const uint32_t arrIdx = static_cast<uint32_t>(cameras_.size());
65 arrIdx < DefaultMaterialCameraConstants::MAX_CAMERA_COUNT) {
66 #if (CORE3D_VALIDATION_ENABLED == 1)
67 if ((camera.id != RenderSceneDataConstants::INVALID_ID) || (!camera.name.empty())) {
68 for (const auto& cam : cameras_) {
69 if ((camera.id == cam.id) || ((!camera.name.empty()) && (camera.name == cam.name))) {
70 CORE_LOG_ONCE_W(to_string(camera.id) + camera.name,
71 "CORE_VALIDATION: non unique camera id: %" PRIu64 " or name: %s", camera.id,
72 camera.name.c_str());
73 }
74 }
75 }
76 #endif
77 cameras_.push_back(camera);
78 } else {
79 #if (CORE3D_VALIDATION_ENABLED == 1)
80 CORE_LOG_ONCE_W("drop_camera_count_full", "CORE3D_VALIDATION: camera dropped (max count: %u)",
81 DefaultMaterialCameraConstants::MAX_CAMERA_COUNT);
82 #endif
83 }
84 }
85
AddEnvironment(const RenderCamera::Environment & environment)86 void RenderDataStoreDefaultCamera::AddEnvironment(const RenderCamera::Environment& environment)
87 {
88 #if (CORE3D_VALIDATION_ENABLED == 1)
89 if (environment.id != RenderSceneDataConstants::INVALID_ID) {
90 for (const auto& env : environments_) {
91 if (environment.id == env.id) {
92 CORE_LOG_ONCE_W("rdsdc_add_env" + to_string(environment.id),
93 "CORE_VALIDATION: non unique camera id: %" PRIu64, env.id);
94 }
95 }
96 }
97 #endif
98 if (environment.multiEnvCount != 0U) {
99 hasBlendEnvironments_ = true;
100 }
101 // NOTE: there's only per camera environment limit at the moment, no environment limit for scene
102 environments_.push_back(environment);
103 }
104
GetCameras() const105 array_view<const RenderCamera> RenderDataStoreDefaultCamera::GetCameras() const
106 {
107 return array_view<const RenderCamera>(cameras_.data(), cameras_.size());
108 }
109
GetCamera(const string_view name) const110 RenderCamera RenderDataStoreDefaultCamera::GetCamera(const string_view name) const
111 {
112 for (const auto& cam : cameras_) {
113 if (cam.name == name) {
114 return cam;
115 }
116 }
117 return {};
118 }
119
GetCamera(const uint64_t id) const120 RenderCamera RenderDataStoreDefaultCamera::GetCamera(const uint64_t id) const
121 {
122 for (const auto& cam : cameras_) {
123 if (cam.id == id) {
124 return cam;
125 }
126 }
127 return {};
128 }
129
GetCameraIndex(const string_view name) const130 uint32_t RenderDataStoreDefaultCamera::GetCameraIndex(const string_view name) const
131 {
132 for (uint32_t idx = 0; idx < static_cast<uint32_t>(cameras_.size()); ++idx) {
133 if (cameras_[idx].name == name) {
134 return idx;
135 }
136 }
137 return ~0u;
138 }
139
GetCameraIndex(const uint64_t id) const140 uint32_t RenderDataStoreDefaultCamera::GetCameraIndex(const uint64_t id) const
141 {
142 for (uint32_t idx = 0; idx < static_cast<uint32_t>(cameras_.size()); ++idx) {
143 if (cameras_[idx].id == id) {
144 return idx;
145 }
146 }
147 return ~0u;
148 }
149
GetCameraCount() const150 uint32_t RenderDataStoreDefaultCamera::GetCameraCount() const
151 {
152 return static_cast<uint32_t>(cameras_.size());
153 }
154
GetEnvironments() const155 array_view<const RenderCamera::Environment> RenderDataStoreDefaultCamera::GetEnvironments() const
156 {
157 return environments_;
158 }
159
GetEnvironment(const uint64_t id) const160 RenderCamera::Environment RenderDataStoreDefaultCamera::GetEnvironment(const uint64_t id) const
161 {
162 const bool searchForDefaultEnv = (id == RenderSceneDataConstants::INVALID_ID);
163 for (const auto& envRef : environments_) {
164 if ((envRef.id == id) ||
165 (searchForDefaultEnv && (envRef.flags & RenderCamera::Environment::ENVIRONMENT_FLAG_MAIN_BIT))) {
166 return envRef;
167 }
168 }
169 return {};
170 }
171
GetEnvironmentCount() const172 uint32_t RenderDataStoreDefaultCamera::GetEnvironmentCount() const
173 {
174 return static_cast<uint32_t>(environments_.size());
175 }
176
HasBlendEnvironments() const177 bool RenderDataStoreDefaultCamera::HasBlendEnvironments() const
178 {
179 return hasBlendEnvironments_;
180 }
181
GetEnvironmentIndex(const uint64_t id) const182 uint32_t RenderDataStoreDefaultCamera::GetEnvironmentIndex(const uint64_t id) const
183 {
184 const bool searchForDefaultEnv = (id == RenderSceneDataConstants::INVALID_ID);
185 for (size_t idx = 0; idx < environments_.size(); ++idx) {
186 const auto& envRef = environments_[idx];
187 if ((envRef.id == id) ||
188 (searchForDefaultEnv && (envRef.flags & RenderCamera::Environment::ENVIRONMENT_FLAG_MAIN_BIT))) {
189 return static_cast<uint32_t>(idx);
190 }
191 }
192 return 0U;
193 }
194
Create(RENDER_NS::IRenderContext &,char const * name)195 refcnt_ptr<RENDER_NS::IRenderDataStore> RenderDataStoreDefaultCamera::Create(
196 RENDER_NS::IRenderContext&, char const* name)
197 {
198 // device not used
199 return refcnt_ptr<RENDER_NS::IRenderDataStore>(new RenderDataStoreDefaultCamera(name));
200 }
201 CORE3D_END_NAMESPACE()
202