examples/particles/utils.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 #include "utils.h"
  18
  19 using namespace Dali;
  20
  21 Vector3 ToHueSaturationLightness(Vector3 rgb)
  22 {
  23   float min = std::min(rgb.r, std::min(rgb.g, rgb.b));
  24   float max = std::max(rgb.r, std::max(rgb.g, rgb.b));
  25
  26   Vector3 hsl(max - min, 0.f, (max + min) * .5f);
  27   if (hsl.x * hsl.x > .0f)
  28   {
  29     hsl.y = hsl.x / max;
  30     if (max == rgb.r)
  31     {
  32       hsl.x = (rgb.g - rgb.b) / hsl.x;
  33     }
  34     else if(max == rgb.g)
  35     {
  36       hsl.x = 2.f + (rgb.b - rgb.r) / hsl.x;
  37     }
  38     else
  39     {
  40       hsl.x = 4.f + (rgb.r - rgb.g) / hsl.x;
  41     }
  42     hsl.x *= 60.f;
  43     if (hsl.x < 0.f)
  44     {
  45       hsl.x += 360.f;
  46     }
  47   }
  48   else
  49   {
  50     hsl.y = 0.f;
  51   }
  52
  53   return hsl;
  54 }
  55
  56 Vector3 FromHueSaturationLightness(Vector3 hsl)
  57 {
  58   Vector3 rgb;
  59   if (hsl.y * hsl.y > 0.f)
  60   {
  61     if(hsl.x >= 360.f)
  62     {
  63       hsl.x -= 360.f;
  64     }
  65     hsl.x /= 60.f;
  66
  67     int i = FastFloor(hsl.x);
  68     float ff = hsl.x - i;
  69     float p = hsl.z * (1.0 - hsl.y);
  70     float q = hsl.z * (1.0 - (hsl.y * ff));
  71     float t = hsl.z * (1.0 - (hsl.y * (1.f - ff)));
  72
  73     switch (i)
  74     {
  75     case 0:
  76       rgb.r = hsl.z;
  77       rgb.g = t;
  78       rgb.b = p;
  79       break;
  80
  81     case 1:
  82       rgb.r = q;
  83       rgb.g = hsl.z;
  84       rgb.b = p;
  85       break;
  86
  87     case 2:
  88       rgb.r = p;
  89       rgb.g = hsl.z;
  90       rgb.b = t;
  91       break;
  92
  93     case 3:
  94       rgb.r = p;
  95       rgb.g = q;
  96       rgb.b = hsl.z;
  97       break;
  98
  99     case 4:
 100       rgb.r = t;
 101       rgb.g = p;
 102       rgb.b = hsl.z;
 103       break;
 104
 105     case 5:
 106     default:
 107       rgb.r = hsl.z;
 108       rgb.g = p;
 109       rgb.b = q;
 110       break;
 111     }
 112   }
 113   else
 114   {
 115     rgb = Vector3::ONE * hsl.z;
 116   }
 117
 118   return rgb;
 119 }
 120
 121 Geometry CreateCuboidWireframeGeometry()
 122 {
 123 //
 124 // 2---3
 125 // |-  |-
 126 // | 6---7
 127 // | | | |
 128 // 0-|-1 |
 129 //  -|  -|
 130 //   4---5
 131 //
 132   Vector3 vertexData[] = {
 133     Vector3(-.5, -.5, -.5),
 134         Vector3( .5, -.5, -.5),
 135         Vector3(-.5,  .5, -.5),
 136         Vector3( .5,  .5, -.5),
 137         Vector3(-.5, -.5,  .5),
 138         Vector3( .5, -.5,  .5),
 139         Vector3(-.5,  .5,  .5),
 140         Vector3( .5,  .5,  .5),
 141   };
 142
 143   uint16_t indices[] = {
 144     0, 1, 1, 3, 3, 2, 2, 0,
 145         0, 4, 1, 5, 3, 7, 2, 6,
 146         4, 5, 5, 7, 7, 6, 6, 4
 147   };
 148   VertexBuffer vertexBuffer = VertexBuffer::New( Property::Map()
 149     .Add( "aPosition", Property::VECTOR3));
 150   vertexBuffer.SetData(vertexData, std::extent<decltype(vertexData)>::value );
 151
 152   Geometry geometry = Geometry::New();
 153   geometry.AddVertexBuffer( vertexBuffer );
 154   geometry.SetIndexBuffer( indices, std::extent<decltype(indices)>::value );
 155   geometry.SetType(Geometry::LINES);
 156   return geometry;
 157 }
 158
 159 Renderer CreateRenderer(TextureSet textures, Geometry geometry, Shader shader, uint32_t options)
 160 {
 161   Renderer renderer = Renderer::New(geometry, shader);
 162   renderer.SetProperty(Renderer::Property::BLEND_MODE,
 163                   (options & OPTION_BLEND) ? BlendMode::ON : BlendMode::OFF);
 164   renderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE,
 165                   (options & OPTION_DEPTH_TEST) ? DepthTestMode::ON : DepthTestMode::OFF);
 166   renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE,
 167                   (options & OPTION_DEPTH_WRITE) ? DepthWriteMode::ON : DepthWriteMode::OFF);
 168   renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK);
 169
 170   if (!textures)
 171   {
 172     textures = TextureSet::New();
 173   }
 174
 175   renderer.SetTextures(textures);
 176   return renderer;
 177 }
 178
 179 void CenterActor(Actor actor)
 180 {
 181   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
 182   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 183 }
 184
 185 Actor CreateActor()
 186 {
 187   auto actor = Actor::New();
 188   CenterActor(actor);
 189   return actor;
 190 }
 191
 192 Renderer CloneRenderer(Renderer original)
 193 {
 194   Geometry geom = original.GetGeometry();
 195   Shader shader = original.GetShader();
 196   Renderer clone = Renderer::New(geom, shader);
 197
 198   // Copy properties.
 199   Property::IndexContainer indices;
 200   original.GetPropertyIndices(indices);
 201
 202   for (auto& i: indices)
 203   {
 204     auto actualIndex = PropertyRanges::DEFAULT_RENDERER_PROPERTY_START_INDEX + i;
 205     clone.SetProperty(actualIndex, original.GetProperty(actualIndex));
 206   }
 207
 208   // Copy texture references (and create TextureSet, if there's any textures).
 209   TextureSet ts = original.GetTextures();
 210   clone.SetTextures(ts);
 211
 212   return clone;
 213 }
 214
 215 Actor CloneActor(Actor original)
 216 {
 217   using namespace Dali;
 218
 219   auto clone = Actor::New();
 220   clone.SetProperty(Actor::Property::NAME, original.GetProperty(Actor::Property::NAME));
 221
 222   // Copy properties.
 223   // Don't copy every single one of them.
 224   // Definitely don't copy resize policy related things, which will internally enable
 225   // relayout, which in turn will result in losing the ability to set Z size.
 226   for (auto i : {
 227     Actor::Property::PARENT_ORIGIN,
 228     Actor::Property::ANCHOR_POINT,
 229     Actor::Property::SIZE,
 230     Actor::Property::POSITION,
 231     Actor::Property::ORIENTATION,
 232     Actor::Property::SCALE,
 233     Actor::Property::VISIBLE,
 234     Actor::Property::COLOR,
 235     Actor::Property::NAME,
 236   })
 237   {
 238     clone.SetProperty(i, original.GetProperty(i));
 239   }
 240
 241   // Clone renderers.
 242   for(unsigned int i = 0; i < original.GetRendererCount(); ++i)
 243   {
 244     auto rClone = CloneRenderer(original.GetRendererAt(i));
 245     clone.AddRenderer(rClone);
 246   }
 247
 248   // Recurse into children.
 249   for(unsigned int i = 0; i < original.GetChildCount(); ++i)
 250   {
 251     Actor newChild = CloneActor(original.GetChildAt(i));
 252     clone.Add(newChild);
 253   }
 254
 255   return clone;
 256 }