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
