2 * Copyright (c) 2015 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
20 #include "shader-api.h"
23 #include <dali/public-api/object/type-registry.h>
27 #include <rendering/shader-wrapper.h>
38 * Shaders allows custom vertex and color transformations in the GPU
43 * // this will match the default shaders for image
44 * var vertexShader = " void main() \
46 * gl_Position = uProjection * uModelView * vec4(aPosition, 1.0); \
47 * vTexCoord = aTexCoord; \
49 * var fragShader = " void main() \
51 * gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\
53 * var shaderOptions = {
54 * vertexShader: vertexShader,
55 * fragmentShader: fragShader
58 * var shader = new dali.Shader(shaderOptions);
64 namespace // unnamed namespace
67 typedef std::vector< std::string > HintsArray;
72 Shader::ShaderHints hint;
75 const ShaderHintPair ShaderHintTable[]=
77 {"requiresSelfDepthTest", Shader::HINT_REQUIRES_SELF_DEPTH_TEST },
78 {"outputIsTransparent", Shader::HINT_OUTPUT_IS_TRANSPARENT },
79 {"outputIsOpaque", Shader::HINT_OUTPUT_IS_OPAQUE },
80 {"modifiesGeometry", Shader::HINT_MODIFIES_GEOMETRY },
83 const unsigned int ShaderHintTableCount = sizeof(ShaderHintTable)/sizeof(ShaderHintTable[0]);
85 struct ShaderParameters
88 : mHints( Shader::HINT_NONE )
92 Shader::ShaderHints GetShaderHint( const std::string& hint )
94 for( unsigned int i = 0 ; i < ShaderHintTableCount; ++i )
96 if( hint == ShaderHintTable[i].name )
98 return ShaderHintTable[i].hint;
101 return Shader::HINT_NONE;
104 void ProcessHintsArray( const HintsArray& hintsArray )
106 for( HintsArray::const_iterator iter = hintsArray.begin(); iter != hintsArray.end() ; ++iter )
108 mHints= static_cast<Shader::ShaderHints>( mHints | GetShaderHint( *iter ) );
114 return Shader::New( mVertex,
120 std::string mFragment;
121 Shader::ShaderHints mHints;
124 Shader GetShader( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
126 v8::HandleScope handleScope( isolate );
128 v8::Local<v8::Object> object = args.This();
129 v8::Local<v8::External> field = v8::Local<v8::External>::Cast( object->GetInternalField(0) );
130 void* ptr = field->Value();
132 ShaderWrapper* wrapper = static_cast< ShaderWrapper *>(ptr);
133 return wrapper->GetShader();
139 * Create a new Shader
143 * @param {Object} shaderOptions
144 * @param {String} [shaderOptions.vertexShader] VertexShader code for the shader. If not defined, the default version will be used
145 * @param {String} [shaderOptions.fragmentShader] FragmentShader code for the shader. If not defined, the default version will be used
146 * @param {Array} [shaderOptions.shaderHints] Hints for rendering/subdividing geometry, e.g. [ "requiresSelfDepthTest", "outputIsTransparent", "outputIsOpaque","modifiesGeometry" ]
147 * @return {Object} Shader
150 // this will match the default shaders for image
151 var vertexShader = " void main() \
153 gl_Position = uProjection * uModelView * vec4(aPosition, 1.0); \
154 vTexCoord = aTexCoord; \
157 var fragShader = " void main() \
159 gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\
162 var shaderOptions = {
163 vertexShader: vertexShader,
164 fragmentShader: fragShader
167 var shader = new dali.Shader(shaderOptions);
170 Shader ShaderApi::New( v8::Isolate* isolate, const v8::FunctionCallbackInfo< v8::Value >& args )
172 v8::HandleScope handleScope( isolate );
174 ShaderParameters shaderParams;
176 if( args[0]->IsObject() )
178 v8::Local<v8::Object > obj = args[0]->ToObject();
180 v8::Local<v8::Value> vertexValue = obj->Get(v8::String::NewFromUtf8( isolate, "vertexShader"));
181 if( vertexValue->IsString() )
183 shaderParams.mVertex = V8Utils::v8StringToStdString( vertexValue );
186 v8::Local<v8::Value> fragmentValue = obj->Get(v8::String::NewFromUtf8( isolate, "fragmentShader"));
187 if( fragmentValue->IsString() )
189 shaderParams.mFragment = V8Utils::v8StringToStdString( fragmentValue );
192 v8::Local<v8::Value> hints = obj->Get(v8::String::NewFromUtf8( isolate, "shaderHints"));
193 if( hints->IsArray() )
195 HintsArray hintsArray;
196 v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast( hints );
197 for( uint32_t i=0; i < array->Length(); ++i)
199 v8::Handle<v8::Value> entry = array->Get( v8::Integer::New( isolate, i) );
200 if( entry->IsString() )
202 std::string entryString = V8Utils::v8StringToStdString( entry );
203 hintsArray.push_back( entryString );
206 shaderParams.ProcessHintsArray( hintsArray );
210 return shaderParams.NewShader();
213 Shader ShaderApi::GetShaderFromParams( int paramIndex,
215 v8::Isolate* isolate,
216 const v8::FunctionCallbackInfo< v8::Value >& args )
220 v8::HandleScope handleScope( isolate );
221 BaseWrappedObject* wrappedObject = V8Utils::GetWrappedDaliObjectParameter( paramIndex, BaseWrappedObject::SHADER, isolate, args );
225 ShaderWrapper* wrapper = static_cast< ShaderWrapper *>(wrappedObject);
226 return wrapper->GetShader();
234 } // namespace V8Plugin