Line data    Source code

       1             : /**
       2             : Copyright 2013 BlackBerry Inc.
       3             : Copyright (c) 2017-2022 Roman Katuntsev <sbkarr@stappler.org>
       4             : Copyright (c) 2023 Stappler LLC <admin@stappler.dev>
       5             : 
       6             : Licensed under the Apache License, Version 2.0 (the "License");
       7             : you may not use this file except in compliance with the License.
       8             : You may obtain a copy of the License at
       9             : 
      10             : http://www.apache.org/licenses/LICENSE-2.0
      11             : 
      12             : Unless required by applicable law or agreed to in writing, software
      13             : distributed under the License is distributed on an "AS IS" BASIS,
      14             : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      15             : See the License for the specific language governing permissions and
      16             : limitations under the License.
      17             : 
      18             : Original file from GamePlay3D: http://gameplay3d.org
      19             : 
      20             : This file was modified to fit the cocos2d-x project
      21             : This file was modified for stappler project
      22             : */
      23             : 
      24             : #include "SPVec3.h"
      25             : #include "SPGeometry.h"
      26             : 
      27             : namespace STAPPLER_VERSIONIZED stappler::geom {
      28             : 
      29          25 : Vec3::Vec3(const Size3 &s) : x(s.width), y(s.height), z(s.depth) { }
      30             : 
      31          25 : Vec3::Vec3(const Extent3 &s) : x(s.width), y(s.height), z(s.depth) { }
      32             : 
      33          25 : float Vec3::angle(const Vec3& v1, const Vec3& v2) {
      34          25 :         const float dx = v1.y * v2.z - v1.z * v2.y;
      35          25 :         const float dy = v1.z * v2.x - v1.x * v2.z;
      36          25 :         const float dz = v1.x * v2.y - v1.y * v2.x;
      37             : 
      38          25 :         return atan2f(sqrt(dx * dx + dy * dy + dz * dz) + math::MATH_FLOAT_SMALL, dot(v1, v2));
      39             : }
      40             : 
      41          50 : void Vec3::clamp(const Vec3& min, const Vec3& max) {
      42          50 :         assert(!(min.x > max.x || min.y > max.y || min.z > max.z));
      43             : 
      44             :         // Clamp the x value.
      45          50 :         if (x < min.x) {
      46          25 :                 x = min.x;
      47             :         }
      48          50 :         if (x > max.x) {
      49          25 :                 x = max.x;
      50             :         }
      51             : 
      52             :         // Clamp the y value.
      53          50 :         if (y < min.y) {
      54          25 :                 y = min.y;
      55             :         }
      56          50 :         if (y > max.y) {
      57          25 :                 y = max.y;
      58             :         }
      59             : 
      60             :         // Clamp the z value.
      61          50 :         if (z < min.z) {
      62          25 :                 z = min.z;
      63             :         }
      64          50 :         if (z > max.z) {
      65          25 :                 z = max.z;
      66             :         }
      67          50 : }
      68             : 
      69          50 : void Vec3::clamp(const Vec3& v, const Vec3& min, const Vec3& max, Vec3* dst) {
      70          50 :         assert(dst);
      71          50 :         assert(!(min.x > max.x || min.y > max.y || min.z > max.z));
      72             : 
      73             :         // Clamp the x value.
      74          50 :         dst->x = v.x;
      75          50 :         if (dst->x < min.x) {
      76          25 :                 dst->x = min.x;
      77             :         }
      78          50 :         if (dst->x > max.x) {
      79          25 :                 dst->x = max.x;
      80             :         }
      81             : 
      82             :         // Clamp the y value.
      83          50 :         dst->y = v.y;
      84          50 :         if (dst->y < min.y) {
      85          25 :                 dst->y = min.y;
      86             :         }
      87          50 :         if (dst->y > max.y) {
      88          25 :                 dst->y = max.y;
      89             :         }
      90             : 
      91             :         // Clamp the z value.
      92          50 :         dst->z = v.z;
      93          50 :         if (dst->z < min.z) {
      94          25 :                 dst->z = min.z;
      95             :         }
      96          50 :         if (dst->z > max.z) {
      97          25 :                 dst->z = max.z;
      98             :         }
      99          50 : }
     100             : 
     101          75 : Vec3 Vec3::getNormalized() const {
     102          75 :         Vec3 v(*this);
     103          75 :         v.normalize();
     104          75 :         return v;
     105             : }
     106             : 
     107             : #ifdef __LCC__
     108             : 
     109             : const Vec3 Vec3::ZERO(0.0f, 0.0f, 0.0f);
     110             : const Vec3 Vec3::ONE(1.0f, 1.0f, 1.0f);
     111             : const Vec3 Vec3::UNIT_X(1.0f, 0.0f, 0.0f);
     112             : const Vec3 Vec3::UNIT_Y(0.0f, 1.0f, 0.0f);
     113             : const Vec3 Vec3::UNIT_Z(0.0f, 0.0f, 1.0f);
     114             : 
     115             : #endif
     116             : 
     117             : }