void CParticleSystem::ReflectData(CSerializer& serializer) { super::ReflectData(serializer); DECLARE_PROPERTY( serializer, m_fLiveTime, true, 0xFFFFFFFF, _T("生存时间"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_bLoop, true, 0xFFFFFFFF, _T("是否循环"), NULL, NULL, _T("VisibleWhen : m_fLiveTime == -1.0") ); DECLARE_DEPENDENCY_LIST( serializer, m_emitterVector, _T("粒子发射器"), eDT_Strong ); }
void CStencilRenderStateParam::ReflectData(CSerializer& serializer) { super::ReflectData(serializer); DECLARE_PROPERTY(serializer, m_nFail, true, 0xFFFFFFFF, _T("失败模式"), NULL, NULL, NULL); DECLARE_PROPERTY(serializer, m_nZFail, true, 0xFFFFFFFF, _T("Z失败模式"), NULL, NULL, NULL); DECLARE_PROPERTY(serializer, m_nZPass, true, 0xFFFFFFFF, _T("Z成功模式"), NULL, NULL, NULL); }
void CTaskBase::ReflectData(CSerializer& serializer) { super::ReflectData(serializer); DECLARE_PROPERTY(serializer, m_uDelayExecuteMS, true, 0xFFFFFFFF, _T("延迟调用时间(毫秒)"), NULL, _T("当任务开始的时候,延迟一段时间再执行"), NULL); DECLARE_PROPERTY(serializer, m_bBindToCurrScene, true, 0xFFFFFFFF, _T("绑定到当前场景"), NULL, _T("如果为真,那么离开当前场景时,该任务中断"), NULL); DECLARE_PROPERTY(serializer, m_bImmediateCall, true, 0xFFFFFFFF, _T("立即调用"), NULL, _T("如果为真,该任务被添加到管理器的时候立刻调用"), "DefaultValue:true, VisibleWhen:m_uDelayExecuteMS != 0"); }
void CRenderState::ReflectData(CSerializer& serializer) { super::ReflectData(serializer); DECLARE_PROPERTY(serializer, m_bDepthMark, true, 0xFFFFFFFF, _T("Éî¶ÈдÈë"), NULL, NULL, NULL); DECLARE_PROPERTY(serializer, m_bEdgeFlag, true, 0xFFFFFFFF, _T("±ßԵģʽ"), NULL, NULL, NULL); DECLARE_DEPENDENCY_LIST(serializer, m_pRenderStateParams, _T("äÖȾ״̬"), eDT_Weak); }
void CTextBox::ReflectData( CSerializer& serializer ) { super::ReflectData( serializer ); DECLARE_PROPERTY( serializer, m_fXBorderWidth, true, 0xFFFFFFFF, _T("前后端边框宽度"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_fYBorderWidth, true, 0xFFFFFFFF, _T("上下端边框宽度"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_strFontName, true, 0xFFFFFFFF, _T("字体名字"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_uTextSize, true, 0xFFFFFFFF, _T("字体大小"), NULL, NULL, NULL ); }
void CShapeModule::ReflectData(CSerializer& serializer) { super::ReflectData(serializer); DECLARE_PROPERTY(serializer, m_emitShapeType, true, 0xFFFFFFFF, "发射形状", nullptr, "定义了发射点的空间集合,以及初始速率所对应的方向", nullptr); DECLARE_PROPERTY(serializer, m_fRadius, true, 0xFFFFFFFF, "半径", nullptr, nullptr, "VisibleWhen:m_emitShapeType!=eEST_Box && m_emitShapeType!=eEST_Mesh"); DECLARE_PROPERTY(serializer, m_bEmitFromShell, true, 0xFFFFFFFF, "从表面发射", nullptr, nullptr, "VisibleWhen:m_emitShapeType!=eEST_Box && m_emitShapeType!=eEST_Mesh&& m_emitShapeType!=eEST_Edge"); DECLARE_PROPERTY(serializer, m_fAngle, true, 0xFFFFFFFF, "角度", nullptr, nullptr, "VisibleWhen:m_emitShapeType==eEST_Cone"); DECLARE_PROPERTY(serializer, m_fArcForCircle, true, 0xFFFFFFFF, "角度", nullptr, nullptr, "VisibleWhen:m_emitShapeType==eEST_Circle"); DECLARE_PROPERTY(serializer, m_bEmitFromBaseOrVolume, true, 0xFFFFFFFF, "仅从锥底", nullptr, "如果为真,则发射点在锥底,否则在锥空间内", "VisibleWhen:m_emitShapeType==eEST_Cone"); DECLARE_PROPERTY(serializer, m_fConeLength, true, 0xFFFFFFFF, "锥高度", nullptr, nullptr, "VisibleWhen:m_emitShapeType==eEST_Cone"); DECLARE_PROPERTY(serializer, m_boxSize, true, 0xFFFFFFFF, "BOX尺寸", nullptr, nullptr, "VisibleWhen:m_emitShapeType==eEST_Box, DefaultValue:1@1@1"); DECLARE_PROPERTY(serializer, m_bRandomDirection, true, 0xFFFFFFFF, "随机朝向", nullptr, nullptr, nullptr); }
void CTestComponent::ReflectData(CSerializer& serializer) { DECLARE_PROPERTY(serializer, m_floatValue, true, 0xffffffff, _T("生命值"), _T(""), _T(""), _T("DefaultValue: 7.5, SpinStep: 0.7")); DECLARE_PROPERTY(serializer, m_doubleValue, true, 0xffffffff, NULL, NULL, NULL, NULL); DECLARE_PROPERTY(serializer, m_intValue, true, 0xffffffff, _T("个数"), NULL, NULL, _T("DefaultValue: 99, SpinStep: 7")); DECLARE_PROPERTY(serializer, m_uintValue, true, 0xffffffff, NULL, NULL, NULL, _T("SpinStep: 7")); DECLARE_PROPERTY(serializer, m_strValue, true, 0xffffffff, NULL, NULL, NULL, _T("DefaultValue: hastalavista")); DECLARE_PROPERTY(serializer, m_ptrValue, true, 0xffffffff, _T("其他对象"), NULL, NULL, NULL); DECLARE_PROPERTY(serializer, m_listValue, true, 0xffffffff, _T("ListValue"), NULL, NULL, NULL); DECLARE_PROPERTY(serializer, m_enumValue, true, 0xffffffff, _T("EnumValue"), NULL, NULL, GEN_ENUM_PARAM(TestEnumStr, _T("DefaultValue:3"))); DECLARE_PROPERTY(serializer, m_mapValue, true, 0xffffffff, _T("MapValue"), NULL, _T("I'm a test value tip"), NULL); DECLARE_DEPENDENCY(serializer, m_pNextObj, _T("目标对象"), eDT_Weak); DECLARE_DEPENDENCY(serializer, m_pNextObj1, _T("目标对象2"), eDT_Weak); DECLARE_DEPENDENCY(serializer, m_pNextObj2, _T("目标对象3"), eDT_Weak); }
void CVelocityLimitModule::ReflectData(CSerializer& serializer) { super::ReflectData(serializer); DECLARE_PROPERTY(serializer, m_bSeparateAxis, true, 0xFFFFFFFF, "独立坐标轴", nullptr, nullptr, nullptr); DECLARE_PROPERTY(serializer, m_bLocalOrWorld, true, 0xFFFFFFFF, "局部坐标", nullptr, nullptr, "VisibleWhen:m_bSeparateAxis==true"); DECLARE_PROPERTY(serializer, m_speed, true, 0xFFFFFFFF, "速度", nullptr, nullptr, "VisibleWhen:m_bSeparateAxis==false, MinValue:0"); DECLARE_PROPERTY(serializer, m_velocityX, true, 0xFFFFFFFF, "X轴速度限制", nullptr, nullptr, "VisibleWhen:m_bSeparateAxis==true"); DECLARE_PROPERTY(serializer, m_velocityY, true, 0xFFFFFFFF, "Y轴速度限制", nullptr, nullptr, "VisibleWhen:m_bSeparateAxis==true"); DECLARE_PROPERTY(serializer, m_velocityZ, true, 0xFFFFFFFF, "Z轴速度限制", nullptr, nullptr, "VisibleWhen:m_bSeparateAxis==true"); DECLARE_PROPERTY(serializer, m_fDampen, true, 0xFFFFFFFF, "阻尼系数", nullptr, "最终速度 = 当前速度 - (当前速度-速度限制) * 阻尼系数", "MinValue:0,MaxValue:1"); }
void CFloatRenderStateParam::ReflectData(CSerializer& serializer) { super::ReflectData(serializer); DECLARE_PROPERTY(serializer, m_type, true, 0xFFFFFFFF, _T("类型"), NULL, NULL, NULL); DECLARE_PROPERTY(serializer, m_fValue, true, 0xFFFFFFFF, _T("浮点数值"), NULL, NULL, NULL); }
void CScaleParticleAnimation::ReflectData(CSerializer& serializer) { CParticleAnimationBase::ReflectData(serializer); DECLARE_PROPERTY( serializer, m_fBeginScale, true, 0xFFFFFFFF, _T("开始放缩倍数"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_fEndScale, true, 0xFFFFFFFF, _T("结束放缩倍数"), NULL, NULL, NULL ); }
void CShaderUniformData::ReflectData(CSerializer& serializer) { CComponentBase::ReflectData(serializer); DECLARE_PROPERTY(serializer, m_fValue, true, 0xFFFFFFFF, _T("Ъ§Он"), NULL, NULL, NULL); }
void CBlendEquationRenderStateParam::ReflectData(CSerializer& serializer) { super::ReflectData(serializer); DECLARE_PROPERTY(serializer, m_nValue, true, 0xFFFFFFFF, _T("╗В║¤ий╩й"), NULL, NULL, NULL); }
namespace Z { //---------------------------------------------------------------------------- // We expose the following named properties for animation and scripting. //---------------------------------------------------------------------------- static const NamedProperty s_propertyTable[] = { DECLARE_PROPERTY( GradientEffect, PROPERTY_COLOR, StartColor ), DECLARE_PROPERTY( GradientEffect, PROPERTY_COLOR, EndColor ), DECLARE_PROPERTY( GradientEffect, PROPERTY_VEC2, StartPoint ), DECLARE_PROPERTY( GradientEffect, PROPERTY_VEC2, EndPoint ), NULL }; DECLARE_PROPERTY_SET( GradientEffect, s_propertyTable ); //---------------------------------------------------------------------------- // Class data //---------------------------------------------------------------------------- UINT32 GradientEffect::s_NumInstances = NULL; bool GradientEffect::s_GradientShadersLoaded = false; GLuint GradientEffect::s_GradientShaderProgram = 0; HShader GradientEffect::s_hGradientShader; const char* GradientEffect::s_GradientVertexShaderName = "/app/shaders/GradientEffect_vs.glsl"; const char* GradientEffect::s_GradientFragmentShaderName = "/app/shaders/GradientEffect_fs.glsl"; GLint GradientEffect::s_uProjectionMatrix = 0; GLint GradientEffect::s_uModelViewMatrix = 0; GLint GradientEffect::s_uTexture = 0; GLint GradientEffect::s_uGlobalColor = 0; GLint GradientEffect::s_uStartColor = 0; GLint GradientEffect::s_uStartPoint = 0; GLint GradientEffect::s_uEndColor = 0; GLint GradientEffect::s_uEndPoint = 0; GLint GradientEffect::s_uWidth = 0; GLint GradientEffect::s_uHeight = 0; //GLint GradientEffect::s_uTexCoordOffset = 0; const Color GradientEffect::DEFAULT_START_COLOR = Color::White(); const Color GradientEffect::DEFAULT_END_COLOR = Color::Black(); //---------------------------------------------------------------------------- // Object methods //---------------------------------------------------------------------------- GradientEffect::GradientEffect() : m_pGradientVertices(NULL), m_numGradientVertices(0), m_startColor(DEFAULT_START_COLOR), m_endColor(DEFAULT_END_COLOR), m_startPoint(0.5f, 0.0f), m_endPoint(0.5f, 1.0f) { RETAILMSG(ZONE_OBJECT | ZONE_VERBOSE, "GradientEffect( %4d )", m_ID); ATOMIC_INCREMENT( GradientEffect::s_NumInstances ); m_name = "GradientEffect"; memset(&m_frame, 0, sizeof(m_frame)); } GradientEffect::~GradientEffect() { RETAILMSG(ZONE_OBJECT | ZONE_VERBOSE, "\t~GradientEffect( %4d )", m_ID); // Delete the shaders when the last instance is freed if (0 == ATOMIC_DECREMENT( GradientEffect::s_NumInstances )) { RETAILMSG(ZONE_INFO, "~GradientEffect: last instance deleted, freeing Color shaders"); Deinit(); } } GradientEffect* GradientEffect::Clone() const { return new GradientEffect(*this); } GradientEffect::GradientEffect( const GradientEffect& rhs ) : OpenGLESEffect(), m_pGradientVertices(NULL), m_numGradientVertices(0), m_startColor(DEFAULT_START_COLOR), m_endColor(DEFAULT_END_COLOR), m_startPoint(0.5f, 0.0f), m_endPoint(0.5f, 1.0f) { RETAILMSG(ZONE_OBJECT | ZONE_VERBOSE, "GradientEffect( %4d ) (copy ctor)", m_ID); ATOMIC_INCREMENT( GradientEffect::s_NumInstances ); m_name = "GradientEffect"; memset(&m_frame, 0, sizeof(m_frame)); *this = rhs; } GradientEffect& GradientEffect::operator=( const GradientEffect& rhs ) { // Avoid self-assignment. if (this == &rhs) return *this; // Copy base class (is there a cleaner syntax?) OpenGLESEffect::operator=(rhs); // SHALLOW COPY: m_numGradientVertices = rhs.m_numGradientVertices; m_startColor = rhs.m_startColor; m_endColor = rhs.m_endColor; m_startPoint = rhs.m_startPoint; m_endPoint = rhs.m_endPoint; // DEEP COPY: vertices if (rhs.m_pGradientVertices) { SAFE_ARRAY_DELETE(m_pGradientVertices); m_pGradientVertices = new Vertex[ rhs.m_numGradientVertices ]; memcpy(m_pGradientVertices, rhs.m_pGradientVertices, sizeof(Vertex)*rhs.m_numGradientVertices); } // Give it a new name with a random suffix char instanceName[MAX_NAME]; sprintf(instanceName, "%s_%X", rhs.m_name.c_str(), (unsigned int)Platform::Random()); m_name = string(instanceName); return *this; } #pragma mark - #pragma mark Drawing RESULT GradientEffect::DrawTriangleStrip( Vertex *pVertices, UINT32 numVertices ) { return GradientEffect::Draw( pVertices, numVertices, PRIMITIVE_TYPE_TRIANGLE_STRIP ); } RESULT GradientEffect::DrawTriangleList( Vertex *pVertices, UINT32 numVertices ) { return GradientEffect::Draw( pVertices, numVertices, PRIMITIVE_TYPE_TRIANGLE_LIST ); } RESULT GradientEffect::Draw( Vertex *pVertices, UINT32 numVertices, PRIMITIVE_TYPE primitiveType ) { DEBUGMSG(ZONE_SHADER, "GradientEffect[%d]::DrawTriangleStrip()", m_ID); RESULT rval = S_OK; Rectangle sourceRect; Rectangle textureRect; Util::GetBoundingRect ( pVertices, numVertices, &sourceRect ); Util::GetTextureMapping( pVertices, numVertices, &textureRect ); // Reinit if our source frame changes, i.e. the object // we're drawing is being scaled. Util::GetBoundingRect( m_pGradientVertices, m_numGradientVertices, &m_gradientRect ); if (!Util::CompareRectangles(sourceRect, m_gradientRect) || !m_pGradientVertices || m_frameChanged) { CHR(InitScratchSurfaces( sourceRect, textureRect )); m_frameChanged = false; } // Assign values to shader parameters. // TODO: move to BeginFrame()? VERIFYGL(glUseProgram(s_GradientShaderProgram)); VERIFYGL(glUniformMatrix4fv(s_uProjectionMatrix, 1, GL_FALSE, (GLfloat*)m_projectionMatrix.Pointer())); VERIFYGL(glUniformMatrix4fv(s_uModelViewMatrix, 1, GL_FALSE, (GLfloat*)m_modelViewMatrix.Pointer())); VERIFYGL(glUniform1i(s_uTexture, 0)); VERIFYGL(glUniform4f(s_uGlobalColor, m_globalColor.floats.r, m_globalColor.floats.g, m_globalColor.floats.b, m_globalColor.floats.a)); VERIFYGL(glUniform4f(s_uStartColor, m_startColor.floats.r, m_startColor.floats.g, m_startColor.floats.b, m_startColor.floats.a)); VERIFYGL(glUniform2f(s_uStartPoint, (m_startPoint.x * textureRect.width) + textureRect.x, (m_startPoint.y * textureRect.height) + textureRect.y)); VERIFYGL(glUniform4f(s_uEndColor, m_endColor.floats.r, m_endColor.floats.g, m_endColor.floats.b, m_endColor.floats.a)); VERIFYGL(glUniform2f(s_uEndPoint, (m_endPoint.x * textureRect.width) + textureRect.x, (m_endPoint.y * textureRect.height) + textureRect.y)); VERIFYGL(glUniform1f(s_uWidth, textureRect.width)); VERIFYGL(glUniform1f(s_uHeight, textureRect.height)); // Draw the mesh with gradient applies. VERIFYGL(glVertexAttribPointer(ATTRIBUTE_VERTEX_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), &m_pGradientVertices->x)); VERIFYGL(glVertexAttribPointer(ATTRIBUTE_VERTEX_DIFFUSE, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex), &m_pGradientVertices->color)); VERIFYGL(glVertexAttribPointer(ATTRIBUTE_VERTEX_TEXTURE_COORD0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), &m_pGradientVertices->texCoord[0])); switch (primitiveType) { // NOTE: for this effect we ignore the passed-in vertices and draw a triangle list (GL_TRIANGLES) not a triangle strip (GL_TRIANGLE_STRIP). case PRIMITIVE_TYPE_TRIANGLE_STRIP: case PRIMITIVE_TYPE_TRIANGLE_LIST: VERIFYGL(glDrawArrays(GL_TRIANGLES, 0, m_numGradientVertices)); break; default: // TODO: might it ever be useful to apply Color to a field of point sprites? DEBUGCHK(0); } Exit: return rval; } void GradientEffect::SetStartColor( const Color& color ) { m_startColor = color; } Color GradientEffect::GetStartColor() { return m_startColor; } void GradientEffect::SetStartPoint( const vec2& point ) { m_startPoint = point; } vec2 GradientEffect::GetStartPoint() { return m_startPoint; } void GradientEffect::SetEndColor( const Color& color ) { m_endColor = color; } Color GradientEffect::GetEndColor() { return m_endColor; } void GradientEffect::SetEndPoint( const vec2& point ) { m_endPoint = point; } vec2 GradientEffect::GetEndPoint() { return m_endPoint; } RESULT GradientEffect::InitScratchSurfaces( Rectangle& sourceRect, Rectangle& textureRect ) { RESULT rval = S_OK; // We render a mesh in place of the (likely) quad sent down from the caller. // This allows for more fine-grained gradients, while still keeping the math in // the vertex shader. // // Create the new mesh with the same position and dimensions, // and a reasonable number of number of triangles (so the gradient looks smooth. float uStart = textureRect.x; float uEnd = textureRect.x + textureRect.width; float vStart = textureRect.y; float vEnd = textureRect.y + textureRect.height; SAFE_ARRAY_DELETE(m_pGradientVertices); CHR(Util::CreateTriangleList( &sourceRect, 5, 5, &m_pGradientVertices, &m_numGradientVertices, uStart, uEnd, vStart, vEnd )); // TODO: create a VBO. Exit: return rval; } //---------------------------------------------------------------------------- // Class methods //---------------------------------------------------------------------------- GradientEffect* GradientEffect::CreateInstance() { DEBUGMSG(ZONE_SHADER, "GradientEffect::CreateInstance()"); RESULT rval = S_OK; GradientEffect* pEffect = NULL; if (Platform::IsOpenGLES2()) { if (!s_GradientShadersLoaded) { CHR(Init()); } CPREx(pEffect = new GradientEffect(), E_OUTOFMEMORY); } else { RETAILMSG(ZONE_WARN, "Device doesn't support GradientEffect."); } Exit: return pEffect; } RESULT GradientEffect::Init() { RETAILMSG(ZONE_SHADER, "GradientEffect::Init()"); RESULT rval = S_OK; if (s_GradientShadersLoaded) { return S_OK; } CHR(OpenGLESEffect::Init()); CHR(ShaderMan.CreateShader( "GradientEffect", s_GradientVertexShaderName, s_GradientFragmentShaderName, &s_hGradientShader )); // Save uniform handles. s_GradientShaderProgram = ShaderMan.GetShaderProgramID( s_hGradientShader ); VERIFYGL(glUseProgram(s_GradientShaderProgram)); VERIFYGL(s_uModelViewMatrix = glGetUniformLocation(s_GradientShaderProgram, "uMatModelView")); VERIFYGL(s_uProjectionMatrix = glGetUniformLocation(s_GradientShaderProgram, "uMatProjection")); VERIFYGL(s_uTexture = glGetUniformLocation(s_GradientShaderProgram, "uTexture")); VERIFYGL(s_uStartColor = glGetUniformLocation(s_GradientShaderProgram, "uStartColor")); VERIFYGL(s_uStartPoint = glGetUniformLocation(s_GradientShaderProgram, "uStartPoint")); VERIFYGL(s_uEndColor = glGetUniformLocation(s_GradientShaderProgram, "uEndColor")); VERIFYGL(s_uEndPoint = glGetUniformLocation(s_GradientShaderProgram, "uEndPoint")); VERIFYGL(s_uGlobalColor = glGetUniformLocation(s_GradientShaderProgram, "uGlobalColor")); VERIFYGL(s_uWidth = glGetUniformLocation(s_GradientShaderProgram, "uWidth")); VERIFYGL(s_uHeight = glGetUniformLocation(s_GradientShaderProgram, "uHeight")); // VERIFYGL(s_uTexCoordOffset = glGetUniformLocation(s_GradientShaderProgram, "uTexCoordOffset")); s_GradientShadersLoaded = true; Exit: return rval; } RESULT GradientEffect::Deinit() { RETAILMSG(ZONE_SHADER, "GradientEffect::Deinit()"); RESULT rval = S_OK; CHR(ShaderMan.Release( s_hGradientShader )); s_GradientShaderProgram = 0; s_GradientShadersLoaded = false; Exit: if (FAILED(rval)) { RETAILMSG(ZONE_ERROR, "ERROR: GradientEffect::Deinit(): failed to free shaders"); } return rval; } HShader GradientEffect::GetShader() { return s_hGradientShader; } IProperty* GradientEffect::GetProperty( const string& propertyName ) const { return s_properties.Get( this, propertyName ); } } // END namespace Z
void CProgressBar::ReflectData( CSerializer& serializer ) { super::ReflectData( serializer ); DECLARE_PROPERTY( serializer, m_uCurrentProgress, true, 0xFFFFFFFF, _T("当前进度"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_fragForeGround, true, 0xFFFFFFFF, _T("前景图片"), NULL, NULL, NULL ); }
/* static */ void ES_MathBuiltins::PopulateMathClass(ES_Context *context, ES_Class_Singleton *prototype_class) { OP_ASSERT(prototype_class->GetPropertyTable()->Capacity() >= ES_MathBuiltinsCount); JString **idents = context->rt_data->idents; ES_Layout_Info layout; DECLARE_PROPERTY(ES_MathBuiltins, abs, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, acos, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, asin, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, atan, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, atan2, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, ceil, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, cos, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, exp, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, floor, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, log, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, max, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, min, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, pow, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, random, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, round, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, sin, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, sqrt, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, tan, DE, ES_STORAGE_OBJECT); DECLARE_PROPERTY(ES_MathBuiltins, E, RO | DE | DD, ES_STORAGE_DOUBLE); DECLARE_PROPERTY(ES_MathBuiltins, LN10, RO | DE | DD, ES_STORAGE_DOUBLE); DECLARE_PROPERTY(ES_MathBuiltins, LN2, RO | DE | DD, ES_STORAGE_DOUBLE); DECLARE_PROPERTY(ES_MathBuiltins, LOG2E, RO | DE | DD, ES_STORAGE_DOUBLE); DECLARE_PROPERTY(ES_MathBuiltins, LOG10E, RO | DE | DD, ES_STORAGE_DOUBLE); DECLARE_PROPERTY(ES_MathBuiltins, PI, RO | DE | DD, ES_STORAGE_DOUBLE); DECLARE_PROPERTY(ES_MathBuiltins, SQRT1_2, RO | DE | DD, ES_STORAGE_DOUBLE); DECLARE_PROPERTY(ES_MathBuiltins, SQRT2, RO | DE | DD, ES_STORAGE_DOUBLE); }
void CControl::ReflectData( CSerializer& serializer ) { super::ReflectData( serializer ); DECLARE_PROPERTY( serializer, m_vec2Anchor, true, 0xFFFFFFFF, _T("锚点"), NULL, NULL, _T("SpinStep:0.1f, MinValue:0.f, MaxValue:1.f") ); DECLARE_PROPERTY( serializer, m_vec2AbsolutePosition, true, 0xFFFFFFFF, _T("绝对位置"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_vec2PercentPosition, true, 0xFFFFFFFF, _T("百分比位置"), NULL, NULL, _T("SpinStep:0.1f, MinValue:-1.f, MaxValue:1.f") ); DECLARE_PROPERTY( serializer, m_vec2Size, true, 0xFFFFFFFF, _T("尺寸"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_vec2PercentSize, true, 0xFFFFFFFF, _T("百分比尺寸"), NULL, NULL, _T("SpinStep:0.1f, MinValue:0.f, MaxValue:1.f") ); DECLARE_PROPERTY( serializer, m_color, true, 0xFFFFFFFF, _T("颜色"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_bUseInheritColorScale, true, 0xFFFFFFFF, _T("颜色继承"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_bResiveTouchEvent, true, 0xFFFFFFFF, _T("接收触摸事件"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_bResponseClickEvent, true, 0xFFFFFFFF, _T("响应点击事件"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_bDispatchEventToParent, true, 0xFFFFFFFF, _T("事件传递到父级"), NULL, NULL, NULL ); DECLARE_PROPERTY( serializer, m_bEnable, true, 0xFFFFFFFF, _T("是否可用"), NULL, NULL, NULL ); DECLARE_PROPERTY(serializer, m_strPressAnimationName, true, 0xFFFFFFFF, _T("按下动画"), NULL, NULL, NULL); DECLARE_PROPERTY(serializer, m_strReleaseAimationName, true, 0xFFFFFFFF, _T("弹起动画"), NULL, NULL, NULL); DECLARE_DEPENDENCY( serializer, m_pClickAction, _T("点击事件"), eDT_Weak ); DECLARE_DEPENDENCY( serializer, m_pClickedAction, _T("点击弹起事件"), eDT_Weak ); HIDE_PROPERTY(m_pos); }
void CSkeleton::ReflectData(CSerializer& serializer) { super::ReflectData(serializer); DECLARE_PROPERTY(serializer, m_uTestComponentValue, true, 0xffffffff, _T("TestValue"), NULL, _T("I'm a test bool tip"), NULL); }
void CColorParticleAnimation::ReflectData(CSerializer& serializer) { super::ReflectData(serializer); DECLARE_PROPERTY( serializer, m_colorSpline, true, 0xFFFFFFFF, _T("颜色样条"), NULL, NULL, NULL ); }
namespace Z { //---------------------------------------------------------------------------- // We expose the following named properties for animation and scripting. //---------------------------------------------------------------------------- static const NamedProperty s_propertyTable[] = { DECLARE_PROPERTY( RippleEffect, PROPERTY_UINT32, Rows ), DECLARE_PROPERTY( RippleEffect, PROPERTY_UINT32, Columns ), DECLARE_PROPERTY( RippleEffect, PROPERTY_UINT32, Padding ), DECLARE_PROPERTY( RippleEffect, PROPERTY_VEC2, Origin ), DECLARE_PROPERTY( RippleEffect, PROPERTY_FLOAT, Amplitude ), DECLARE_PROPERTY( RippleEffect, PROPERTY_FLOAT, Speed ), DECLARE_PROPERTY( RippleEffect, PROPERTY_FLOAT, Radius ), DECLARE_PROPERTY( RippleEffect, PROPERTY_FLOAT, WaveLength ), DECLARE_PROPERTY( RippleEffect, PROPERTY_FLOAT, NumWaves ), DECLARE_PROPERTY( RippleEffect, PROPERTY_COLOR, Color ), NULL }; DECLARE_PROPERTY_SET( RippleEffect, s_propertyTable ); //---------------------------------------------------------------------------- // Class data //---------------------------------------------------------------------------- UINT32 RippleEffect::s_NumInstances = NULL; bool RippleEffect::s_RippleShadersLoaded = false; GLuint RippleEffect::s_RippleShaderProgram = 0; HShader RippleEffect::s_hRippleShader; const char* RippleEffect::s_RippleVertexShaderName = "/app/shaders/RippleEffect_vs.glsl"; const char* RippleEffect::s_RippleFragmentShaderName = "/app/shaders/RippleEffect_fs.glsl"; GLint RippleEffect::s_uProjectionMatrix = 0; GLint RippleEffect::s_uModelViewMatrix = 0; GLint RippleEffect::s_uTexture = 0; GLint RippleEffect::s_uGlobalColor = 0; GLint RippleEffect::s_uOrigin = 0; GLint RippleEffect::s_uAmplitude = 0; GLint RippleEffect::s_uTime = 0; GLint RippleEffect::s_uRadius = 0; GLint RippleEffect::s_uHalfWaveLength = 0; GLint RippleEffect::s_uNumWaves = 0; GLint RippleEffect::s_uColor = 0; const UINT8 RippleEffect::DEFAULT_ROWS = 15; const UINT8 RippleEffect::DEFAULT_COLUMNS = 15; const UINT32 RippleEffect::DEFAULT_PADDING = 20; const float RippleEffect::DEFAULT_AMPLITUDE = 2.0; const float RippleEffect::DEFAULT_ORIGIN_X = 0.5; const float RippleEffect::DEFAULT_ORIGIN_Y = 0.5; const float RippleEffect::DEFAULT_SPEED = 4.0; const float RippleEffect::DEFAULT_RADIUS = 0.0; const float RippleEffect::DEFAULT_WAVE_LENGTH = 20.0; const float RippleEffect::DEFAULT_NUM_WAVES = 1.0; const Color RippleEffect::DEFAULT_COLOR = Color::Clear(); const float RippleEffect::MAX_AMPLITUDE = 100.0; const float RippleEffect::MAX_SPEED = 100.0; //---------------------------------------------------------------------------- // Object methods //---------------------------------------------------------------------------- RippleEffect::RippleEffect() : m_pRippledVertices(NULL), m_numRippledVertices(0), m_rows(DEFAULT_ROWS), m_columns(DEFAULT_COLUMNS), m_padding(DEFAULT_PADDING), m_fWaveLength(DEFAULT_WAVE_LENGTH), m_fNumWaves(DEFAULT_NUM_WAVES), m_fAmplitude(DEFAULT_AMPLITUDE), m_fSpeed(DEFAULT_SPEED), m_fRadius(DEFAULT_RADIUS), m_color(DEFAULT_COLOR), m_origin(0,0) { RETAILMSG(ZONE_OBJECT | ZONE_VERBOSE, "RippleEffect( %4d )", m_ID); ATOMIC_INCREMENT( RippleEffect::s_NumInstances ); // This effect needs render-to-texture. The result is then presented on-screen in ::EndFrame() m_needsRenderTarget = true; m_isPostEffect = true; m_name = "RippleEffect"; memset(&m_frame, 0, sizeof(m_frame)); } RippleEffect::~RippleEffect() { RETAILMSG(ZONE_OBJECT | ZONE_VERBOSE, "\t~RippleEffect( %4d )", m_ID); SAFE_ARRAY_DELETE(m_pRippledVertices); // Delete the shaders when the last instance is freed if (0 == ATOMIC_DECREMENT( RippleEffect::s_NumInstances )) { RETAILMSG(ZONE_INFO, "~RippleEffect: last instance deleted, freeing Ripple shaders"); Deinit(); } } RippleEffect* RippleEffect::Clone() const { return new RippleEffect(*this); } RippleEffect::RippleEffect( const RippleEffect& rhs ) : OpenGLESEffect(), m_pRippledVertices(NULL), m_numRippledVertices(0), m_rows(DEFAULT_ROWS), m_columns(DEFAULT_COLUMNS), m_padding(DEFAULT_PADDING), m_fWaveLength(DEFAULT_WAVE_LENGTH), m_fNumWaves(DEFAULT_NUM_WAVES), m_fAmplitude(DEFAULT_AMPLITUDE), m_fSpeed(DEFAULT_SPEED), m_fRadius(DEFAULT_RADIUS), m_color(DEFAULT_COLOR), m_origin(0,0) { RETAILMSG(ZONE_OBJECT | ZONE_VERBOSE, "RippleEffect( %4d ) (copy ctor)", m_ID); ATOMIC_INCREMENT( RippleEffect::s_NumInstances ); m_name = "RippleEffect"; memset(&m_frame, 0, sizeof(m_frame)); *this = rhs; } RippleEffect& RippleEffect::operator=( const RippleEffect& rhs ) { // Avoid self-assignment. if (this == &rhs) return *this; // Copy base class (is there a cleaner syntax?) OpenGLESEffect::operator=(rhs); // SHALLOW COPY: m_numRippledVertices = rhs.m_numRippledVertices; m_rows = rhs.m_rows; m_columns = rhs.m_columns; m_padding = rhs.m_padding; m_fAmplitude = rhs.m_fAmplitude; m_fSpeed = rhs.m_fSpeed; m_fRadius = rhs.m_fRadius; m_fWaveLength = rhs.m_fWaveLength; m_fNumWaves = rhs.m_fNumWaves; m_origin = rhs.m_origin; m_color = rhs.m_color; // DEEP COPY: vertices if (rhs.m_pRippledVertices) { SAFE_ARRAY_DELETE(m_pRippledVertices); m_pRippledVertices = new Vertex[ rhs.m_numRippledVertices ]; memcpy(m_pRippledVertices, rhs.m_pRippledVertices, sizeof(Vertex)*rhs.m_numRippledVertices); } // Give it a new name with a random suffix char instanceName[MAX_NAME]; sprintf(instanceName, "%s_%X", rhs.m_name.c_str(), (unsigned int)Platform::Random()); m_name = string(instanceName); return *this; } #pragma mark - #pragma mark Drawing RESULT RippleEffect::DrawTriangleStrip( Vertex *pVertices, UINT32 numVertices ) { return RippleEffect::Draw( pVertices, numVertices, PRIMITIVE_TYPE_TRIANGLE_STRIP ); } RESULT RippleEffect::DrawTriangleList( Vertex *pVertices, UINT32 numVertices ) { return RippleEffect::Draw( pVertices, numVertices, PRIMITIVE_TYPE_TRIANGLE_LIST ); } RESULT RippleEffect::Draw( Vertex *pVertices, UINT32 numVertices, PRIMITIVE_TYPE primitiveType ) { DEBUGMSG(ZONE_SHADER, "RippleEffect[%d]::DrawTriangleStrip()", m_ID); RESULT rval = S_OK; Rectangle sourceRect; Rectangle textureRect; Util::GetBoundingRect ( pVertices, numVertices, &sourceRect ); Util::GetTextureMapping( pVertices, numVertices, &textureRect ); // TODO: reinit if our source frame changes, i.e. the object // we're rippling is being scaled. if (!m_pRippledVertices || m_frameChanged) { CHR(InitScratchSurfaces( sourceRect, textureRect )); m_frameChanged = false; } // Assign values to shader parameters. // TODO: move to BeginPass()? VERIFYGL(glUseProgram(s_RippleShaderProgram)); VERIFYGL(glUniformMatrix4fv(s_uProjectionMatrix, 1, GL_FALSE, (GLfloat*)m_projectionMatrix.Pointer())); VERIFYGL(glUniformMatrix4fv(s_uModelViewMatrix, 1, GL_FALSE, (GLfloat*)m_modelViewMatrix.Pointer())); VERIFYGL(glUniform1i(s_uTexture, 0)); VERIFYGL(glUniform4f(s_uGlobalColor, m_globalColor.floats.r, m_globalColor.floats.g, m_globalColor.floats.b, m_globalColor.floats.a)); VERIFYGL(glUniform1f(s_uAmplitude, m_fAmplitude)); VERIFYGL(glUniform1f(s_uTime, m_fSpeed * GameTime.GetTimeDouble())); VERIFYGL(glUniform1f(s_uRadius, m_fRadius)); VERIFYGL(glUniform1f(s_uHalfWaveLength, m_fWaveLength/2.0f)); VERIFYGL(glUniform1f(s_uNumWaves, m_fNumWaves)); VERIFYGL(glUniform2f(s_uOrigin, m_origin.x, m_origin.y)); VERIFYGL(glUniform4f(s_uColor, m_color.floats.r, m_color.floats.g, m_color.floats.b, m_color.floats.a)); // Draw the texture mapped onto the rippling mesh. VERIFYGL(glVertexAttribPointer(ATTRIBUTE_VERTEX_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), &m_pRippledVertices->x)); VERIFYGL(glVertexAttribPointer(ATTRIBUTE_VERTEX_DIFFUSE, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex), &m_pRippledVertices->color)); VERIFYGL(glVertexAttribPointer(ATTRIBUTE_VERTEX_TEXTURE_COORD0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), &m_pRippledVertices->texCoord[0])); switch (primitiveType) { // NOTE: for this effect we ignore the passed-in vertices and draw a triangle list (GL_TRIANGLES) not a triangle strip (GL_TRIANGLE_STRIP). case PRIMITIVE_TYPE_TRIANGLE_STRIP: case PRIMITIVE_TYPE_TRIANGLE_LIST: VERIFYGL(glDrawArrays(GL_TRIANGLES, 0, m_numRippledVertices)); break; default: // TODO: might it ever be useful to apply Ripple to a field of point sprites? DEBUGCHK(0); } Exit: return rval; } void RippleEffect::SetPadding( UINT32 padding ) { m_padding = padding; } UINT32 RippleEffect::GetPadding() { return m_padding; } void RippleEffect::SetRows( UINT8 rows ) { m_rows = rows; } UINT8 RippleEffect::GetRows() { return m_rows; } void RippleEffect::SetColumns( UINT8 columns ) { m_columns = columns; } UINT8 RippleEffect::GetColumns() { return m_columns; } void RippleEffect::SetAmplitude( float amplitude ) { m_fAmplitude = MIN(amplitude, MAX_AMPLITUDE); } float RippleEffect::GetAmplitude() { return m_fAmplitude; } void RippleEffect::SetSpeed( float speed ) { m_fSpeed = MIN(speed, MAX_SPEED); } float RippleEffect::GetSpeed() { return m_fSpeed; } void RippleEffect::SetRadius( float radius ) { m_fRadius = MAX(radius, 0.0f); } float RippleEffect::GetRadius() { return m_fRadius; } void RippleEffect::SetWaveLength( float waveLength ) { m_fWaveLength = MAX(waveLength, 1.0f); } float RippleEffect::GetWaveLength() { return m_fWaveLength; } void RippleEffect::SetNumWaves( float numWaves ) { m_fNumWaves = MAX(numWaves, 1.0f); } float RippleEffect::GetNumWaves() { return m_fNumWaves; } void RippleEffect::SetColor( const Color& color ) { m_color = color; } Color RippleEffect::GetColor() { return m_color; } void RippleEffect::SetOrigin( const vec2& origin ) { m_origin = origin; } vec2 RippleEffect::GetOrigin() { return m_origin; } RESULT RippleEffect::InitScratchSurfaces( Rectangle& sourceRect, Rectangle& textureRect ) { RESULT rval = S_OK; // We render an animated mesh in place of the triangle mesh sent down from the caller. // // Create the new mesh with the same position and dimensions (plus optional padding), // and a reasonable number of number of triangles (so the ripples look fluid). Rectangle paddedRect = sourceRect; paddedRect.x -= m_padding; paddedRect.y -= m_padding; paddedRect.width += m_padding*2; paddedRect.height += m_padding*2; // Rectangle paddedTextureRect = textureRect; // paddedTextureRect.x -= sourceRect.width - paddedRect.width; float uStart = textureRect.x; float uEnd = textureRect.x + textureRect.width; float vStart = textureRect.y; float vEnd = textureRect.y + textureRect.height; SAFE_ARRAY_DELETE(m_pRippledVertices); CHR(Util::CreateTriangleList( &paddedRect, m_rows, m_columns, &m_pRippledVertices, &m_numRippledVertices, uStart, uEnd, vStart, vEnd )); // TODO: create a VBO. Exit: return rval; } //---------------------------------------------------------------------------- // Class methods //---------------------------------------------------------------------------- RippleEffect* RippleEffect::CreateInstance() { DEBUGMSG(ZONE_RENDER, "RippleEffect::CreateInstance()"); RESULT rval = S_OK; RippleEffect* pEffect = NULL; if (Platform::IsOpenGLES2()) { if (!s_RippleShadersLoaded) { CHR(Init()); } CPREx(pEffect = new RippleEffect(), E_OUTOFMEMORY); } else { RETAILMSG(ZONE_WARN, "Device doesn't support RippleEffect."); } Exit: return pEffect; } RESULT RippleEffect::Init() { RETAILMSG(ZONE_RENDER, "RippleEffect::Init()"); RESULT rval = S_OK; if (s_RippleShadersLoaded) { return S_OK; } CHR(OpenGLESEffect::Init()); CHR(ShaderMan.CreateShader( "RippleEffect", s_RippleVertexShaderName, s_RippleFragmentShaderName, &s_hRippleShader )); // Save uniform handles. s_RippleShaderProgram = ShaderMan.GetShaderProgramID( s_hRippleShader ); VERIFYGL(glUseProgram(s_RippleShaderProgram)); VERIFYGL(s_uModelViewMatrix = glGetUniformLocation(s_RippleShaderProgram, "uMatModelView")); VERIFYGL(s_uProjectionMatrix = glGetUniformLocation(s_RippleShaderProgram, "uMatProjection")); VERIFYGL(s_uTexture = glGetUniformLocation(s_RippleShaderProgram, "uTexture")); VERIFYGL(s_uGlobalColor = glGetUniformLocation(s_RippleShaderProgram, "uGlobalColor")); VERIFYGL(s_uAmplitude = glGetUniformLocation(s_RippleShaderProgram, "uAmplitude")); VERIFYGL(s_uTime = glGetUniformLocation(s_RippleShaderProgram, "uTime")); VERIFYGL(s_uRadius = glGetUniformLocation(s_RippleShaderProgram, "uRadius")); VERIFYGL(s_uOrigin = glGetUniformLocation(s_RippleShaderProgram, "uOrigin")); VERIFYGL(s_uHalfWaveLength = glGetUniformLocation(s_RippleShaderProgram, "uHalfWaveLength")); VERIFYGL(s_uNumWaves = glGetUniformLocation(s_RippleShaderProgram, "uNumWaves")); VERIFYGL(s_uColor = glGetUniformLocation(s_RippleShaderProgram, "uColor")); s_RippleShadersLoaded = true; Exit: return rval; } RESULT RippleEffect::Deinit() { RETAILMSG(ZONE_RENDER, "RippleEffect::Deinit()"); RESULT rval = S_OK; CHR(ShaderMan.Release( s_hRippleShader )); s_RippleShaderProgram = 0; s_RippleShadersLoaded = false; Exit: if (FAILED(rval)) { RETAILMSG(ZONE_ERROR, "ERROR: RippleEffect::Deinit(): failed to free shaders"); } return rval; } HShader RippleEffect::GetShader() { return s_hRippleShader; } IProperty* RippleEffect::GetProperty( const string& propertyName ) const { return s_properties.Get( this, propertyName ); } } // END namespace Z