plugins/dali-script-v8/src/rendering/renderer-api.cpp

   1 /*
   2  * Copyright (c) 2015 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
  18
  19 // CLASS HEADER
  20 #include "renderer-api.h"
  21
  22 // EXTERNAL INCLUDES
  23 #include <dali/public-api/object/type-registry.h>
  24
  25 // INTERNAL INCLUDES
  26 #include <v8-utils.h>
  27 #include <rendering/renderer-wrapper.h>
  28 #include <rendering/geometry-api.h>
  29 #include <rendering/geometry-wrapper.h>
  30 #include <rendering/texture-set-api.h>
  31 #include <rendering/texture-set-wrapper.h>
  32 #include <rendering/shader-api.h>
  33
  34 namespace Dali
  35 {
  36
  37 namespace V8Plugin
  38 {
  39
  40 /**
  41  * ## Renderer API
  42  *
  43  * Renderer is a handle to an object that can be used to provide an image to a material.
  44  *
  45  * @class Renderer
  46  * @extends Handle
  47  */
  48
  49 Renderer RendererApi::GetRenderer( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
  50 {
  51   v8::HandleScope handleScope( isolate );
  52
  53   v8::Local<v8::Object> object = args.This();
  54   v8::Local<v8::External> field = v8::Local<v8::External>::Cast( object->GetInternalField(0) );
  55   void* ptr = field->Value();
  56
  57   RendererWrapper* wrapper = static_cast< RendererWrapper *>(ptr);
  58   return wrapper->GetRenderer();
  59 }
  60
  61 Renderer RendererApi::GetRendererFromParams( int paramIndex,
  62                                              bool& found,
  63                                              v8::Isolate* isolate,
  64                                              const v8::FunctionCallbackInfo< v8::Value >& args )
  65 {
  66   found = false;
  67
  68   v8::HandleScope handleScope( isolate );
  69   BaseWrappedObject* wrappedObject = V8Utils::GetWrappedDaliObjectParameter( paramIndex, BaseWrappedObject::RENDERER, isolate, args );
  70   if( wrappedObject )
  71   {
  72     found = true;
  73     RendererWrapper* wrapper = static_cast< RendererWrapper *>(wrappedObject);
  74     return wrapper->GetRenderer();
  75   }
  76   else
  77   {
  78     return Renderer();
  79   }
  80 }
  81
  82 /**
  83  * Create a new renderer object.
  84  *
  85  * @constructor
  86  * @method Renderer
  87  * @for Renderer
  88  * @param {Object} geometry The geometry to be used by this renderer
  89  * @param {Object} shader The shader to be used by this renderer
  90  * @return {Object} Renderer
  91  */
  92 Renderer RendererApi::New( const v8::FunctionCallbackInfo< v8::Value >& args )
  93 {
  94   v8::Isolate* isolate = args.GetIsolate();
  95   v8::HandleScope handleScope( isolate );
  96
  97   bool found( false );
  98   Geometry geometry = GeometryApi::GetGeometryFromParams( 0, found, isolate, args );
  99   if( !found )
 100   {
 101     DALI_SCRIPT_EXCEPTION( isolate, "missing geometry from param 0" );
 102     return Renderer();
 103   }
 104
 105   found = false;
 106   Shader shader = ShaderApi::GetShaderFromParams( 1, found, isolate, args );
 107   if( !found )
 108   {
 109     DALI_SCRIPT_EXCEPTION( isolate, "missing shader from param 0" );
 110     return Renderer();
 111   }
 112
 113   return Renderer::New(geometry, shader);
 114 }
 115
 116 /**
 117  * Sets the geometry to be used by this renderer
 118  *
 119  * @method setGeometry
 120  * @for Renderer
 121  * @param {Object} geometry The geometry to be used by this renderer
 122  */
 123 void RendererApi::SetGeometry( const v8::FunctionCallbackInfo< v8::Value >& args )
 124 {
 125   v8::Isolate* isolate = args.GetIsolate();
 126   v8::HandleScope handleScope( isolate );
 127
 128   Renderer renderer = GetRenderer( isolate, args );
 129
 130   bool found( false );
 131   Geometry geometry = GeometryApi::GetGeometryFromParams( 0, found, isolate, args );
 132   if( !found )
 133   {
 134     DALI_SCRIPT_EXCEPTION( isolate, "missing geometry from param 0" );
 135   }
 136   else
 137   {
 138     renderer.SetGeometry(geometry);
 139   }
 140 }
 141
 142 /**
 143  * Gets the geometry used by this renderer
 144  *
 145  * @method getGeometry
 146  * @for Renderer
 147  * @return {Object} The geometry used by this renderer
 148  */
 149 void RendererApi::GetGeometry( const v8::FunctionCallbackInfo<v8::Value>& args )
 150 {
 151   v8::Isolate* isolate = args.GetIsolate();
 152   v8::HandleScope handleScope( isolate );
 153
 154   Renderer renderer = GetRenderer( isolate, args );
 155   Geometry geometry = renderer.GetGeometry();
 156
 157   // Wrap the geometry
 158   v8::Local<v8::Object> localObject = GeometryWrapper::WrapGeometry( isolate, geometry );
 159   args.GetReturnValue().Set( localObject );
 160 }
 161
 162 /**
 163  * Sets the texture set to be used by this renderer
 164  *
 165  * @method setTextures
 166  * @for Renderer
 167  * @param {Object} textureSet The TextureSet to be used by this renderer
 168  */
 169 void RendererApi::SetTextures( const v8::FunctionCallbackInfo< v8::Value >& args )
 170 {
 171   v8::Isolate* isolate = args.GetIsolate();
 172   v8::HandleScope handleScope( isolate );
 173
 174   Renderer renderer = GetRenderer( isolate, args );
 175
 176   bool found( false );
 177   TextureSet textureSet = TextureSetApi::GetTextureSetFromParams( 0, found, isolate, args );
 178   if( !found )
 179   {
 180     DALI_SCRIPT_EXCEPTION( isolate, "missing texture set from param 0" );
 181   }
 182   else
 183   {
 184     renderer.SetTextures(textureSet);
 185   }
 186 }
 187
 188 /**
 189  * Gets the texture set used by this renderer
 190  *
 191  * @method getTextures
 192  * @for Renderer
 193  * @return {Object} The texture set used by this renderer
 194  */
 195 void RendererApi::GetTextures( const v8::FunctionCallbackInfo<v8::Value>& args )
 196 {
 197   v8::Isolate* isolate = args.GetIsolate();
 198   v8::HandleScope handleScope( isolate );
 199
 200   Renderer renderer = GetRenderer( isolate, args );
 201   TextureSet textureSet = renderer.GetTextures();
 202
 203   // Wrap the textureset
 204   v8::Local<v8::Object> localObject = TextureSetWrapper::WrapTextureSet( isolate, textureSet );
 205   args.GetReturnValue().Set( localObject );
 206 }
 207
 208 } // namespace V8Plugin
 209
 210 } // namespace Dali