Support of creating BufferImage from pixel buffer in JavaScript
[platform/core/uifw/dali-toolkit.git] / plugins / dali-script-v8 / src / object / property-buffer-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 // CLASS HEADER
19 #include "property-buffer-api.h"
20
21 // INTERNAL INCLUDES
22 #include <v8-utils.h>
23 #include <object/property-buffer-wrapper.h>
24
25 namespace Dali
26 {
27
28 namespace V8Plugin
29 {
30
31 namespace // unnamed namespace
32 {
33
34 struct PropertyBufferParameters
35 {
36   PropertyBufferParameters()
37       : mSize( 0 )
38   {
39   }
40
41   PropertyBuffer NewPropertyBuffer()
42   {
43     return PropertyBuffer::New( mBufferFormat,
44                                 mSize);
45   }
46
47   Property::Map mBufferFormat;
48   std::size_t mSize;
49 };
50
51 } // unnamed space
52
53 /**
54  * ## PropertyBuffer API
55  *
56  * PropertyBuffer is a handle to an object that contains a buffer of structured properties.
57  * It can be used to provide data to Geometry objects.
58  *
59  * ### Simple example
60  *
61  *```
62  *    var vertexFormat ={ "aPosition" : dali.PROPERTY_VECTOR2 };
63  *    var vertexData = [    0,     1,
64  *                      -0.95,  0.31,
65  *                      -0.59, -0.81,
66  *                       0.59, -0.81,
67  *                       0.95,  0.31];
68  *
69  *    var vertexDataArray = new Float32Array(vertexData.length);
70  *    vertexDataArray.set(vertexData, 0);
71  *    var vertices = new dali.PropertyBuffer(vertexFormat, 5);
72  *    vertices.setData(vertexDataArray);
73  *
74  *    var geometry = new dali.Geometry();
75  *    geometry.addVertexBuffer( vertices );
76  *```
77  * @class PropertyBuffer
78  */
79
80 PropertyBuffer PropertyBufferApi::GetPropertyBuffer( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
81 {
82   v8::HandleScope handleScope( isolate );
83
84   v8::Local<v8::Object> object = args.This();
85   v8::Local<v8::External> field = v8::Local<v8::External>::Cast( object->GetInternalField(0) );
86   void* ptr = field->Value();
87
88   PropertyBufferWrapper* wrapper = static_cast< PropertyBufferWrapper *>(ptr);
89   return wrapper->GetPropertyBuffer();
90 }
91
92 PropertyBuffer PropertyBufferApi::GetPropertyBufferFromParams( int paramIndex,
93                           bool& found,
94                           v8::Isolate* isolate,
95                           const v8::FunctionCallbackInfo< v8::Value >& args )
96 {
97   found = false;
98
99   v8::HandleScope handleScope( isolate );
100   BaseWrappedObject* wrappedObject = V8Utils::GetWrappedDaliObjectParameter( paramIndex, BaseWrappedObject::PROPERTY_BUFFER, isolate, args );
101   if( wrappedObject )
102   {
103     found = true;
104     PropertyBufferWrapper* wrapper = static_cast< PropertyBufferWrapper *>(wrappedObject);
105     return wrapper->GetPropertyBuffer();
106   }
107   else
108   {
109     return PropertyBuffer();
110   }
111 }
112
113 /**
114  * Create a new PropertyBuffer
115  *
116  * PropertyBuffers contains a buffer of structured properties and can be
117  * used to provide data to Geometry objects.
118  *
119  * @constructor
120  * @for PropertyBuffer
121  * @method PropertyBuffer
122  * @param {Object} bufferFormat Map of names and types that describes the components of the buffer
123  * @param {integer} size The number of elements in the property buffer
124  * @return {Object} PropertyBuffer
125  * @example
126  *```
127  *    var bufferFormat = {
128  *                         "aPosition" : dali.PROPERTY_VECTOR2,
129  *                         "aTexCoord" : dali.PROPERTY_VECTOR2,
130  *                         "aHue"      : dali.PROPERTY_FLOAT,
131  *                       };
132  *
133  *    var buffer = new dali.PropertyBuffer(bufferFormat, 5);
134  *```
135  */
136 PropertyBuffer PropertyBufferApi::New( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
137 {
138   v8::HandleScope handleScope( isolate );
139
140   bool found( false );
141   Dali::Property::Map bufferFormat = V8Utils::GetPropertyMapParameter( PARAMETER_0, found, isolate, args);
142   if( !found || bufferFormat.Empty() )
143   {
144     DALI_SCRIPT_EXCEPTION( isolate, "invalid property map parameter" );
145     return PropertyBuffer();
146   }
147
148   found = false;
149   int size = V8Utils::GetIntegerParameter( PARAMETER_1, found, isolate, args, 0);
150   if( !found )
151   {
152     DALI_SCRIPT_EXCEPTION( isolate, "missing buffer size from param 1" );
153     return PropertyBuffer();
154   }
155
156   return PropertyBuffer::New(bufferFormat, static_cast<std::size_t>(size));
157 }
158
159 /**
160  * Update the whole buffer information
161  *
162  * This function expects an array of data with the same format that was given
163  * in the construction, and the number of elements to be the same as the size
164  * of the buffer.
165  *
166  * @method setData
167  * @for PropertyBuffer
168  * @param {Float32Array} data The data that will be copied to the buffer.
169  * @example
170  *```
171  *   var vertexData = [    0,     1,
172  *                     -0.95,  0.31,
173  *                     -0.59, -0.81,
174  *                      0.59, -0.81,
175  *                      0.95,  0.31];
176  *
177  *   var vertexDataArray = new Float32Array(vertexData.length);
178  *   vertexDataArray.set(vertexData, 0);
179  *
180  *   propertyBuffer.setData( vertexDataArray );
181  *```
182  */
183 void PropertyBufferApi::SetData( const v8::FunctionCallbackInfo< v8::Value >& args )
184 {
185   v8::Isolate* isolate = args.GetIsolate();
186   v8::HandleScope handleScope( isolate );
187
188   PropertyBuffer buffer = GetPropertyBuffer( isolate, args );
189
190   bool found( false );
191   void* data = V8Utils::GetArrayBufferViewParameter( PARAMETER_0, found, isolate, args);
192   if( !found )
193   {
194     DALI_SCRIPT_EXCEPTION( isolate, "invalid data parameter" );
195   }
196   else
197   {
198     buffer.SetData( data );
199   }
200 }
201
202 } // namespace V8Plugin
203
204 } // namespace Dali