1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implement node test case class

    15 *

    16 */

    17 

    18 

    19 #include <avkon.rsg>

    20 #include <bctestdomm3g.rsg>

    21 #include <eikenv.h>

    22 #include <eikappui.h>

    23 #include <cm3gloader.h>

    24 #include <rm3gobject.h>

    25 #include <rm3glight.h>

    26 #include <rm3gcamera.h>

    27 #include <rm3gworld.h>

    28 #include <rm3gbackground.h>

    29 #include <rm3gsprite.h>

    30 #include <rm3gappearance.h>

    31 #include <rm3gimage.h>

    32 #include <rm3gnode.h>

    33 #include <rm3gtransformable.h>

    34 #include <rm3gmesh.h>

    35 #include <rm3gindexbuffer.h>

    36 #include <rm3gvertexbuffer.h>

    37 #include <rm3gmorphingmesh.h>

    38 #include <rm3gskinnedmesh.h>

    39 

    40 #include "bctestdomm3gnodecase.h"

    41 #include "bctestdomm3gcontainer.h"

    42 #include "bctestdomm3g.hrh"

    43 

    44 // ======== MEMBER FUNCTIONS ========

    45 

    46 // ---------------------------------------------------------------------------

    47 // Symbian 2nd static Constructor

    48 // ---------------------------------------------------------------------------

    49 //

    50 CBCTestDomM3gNodeCase* CBCTestDomM3gNodeCase::NewL(

    51     CBCTestDomM3gContainer* aContainer )

    52     {

    53     CBCTestDomM3gNodeCase* self =

    54         new( ELeave ) CBCTestDomM3gNodeCase( aContainer );

    55     CleanupStack::PushL( self );

    56     self->ConstructL();

    57     CleanupStack::Pop( self );

    58     return self;

    59     }

    60 

    61 // ---------------------------------------------------------------------------

    62 // C++ default constructor

    63 // ---------------------------------------------------------------------------

    64 //

    65 CBCTestDomM3gNodeCase::CBCTestDomM3gNodeCase(

    66     CBCTestDomM3gContainer* aContainer )

    67     : iContainer( aContainer )

    68     {

    69     }

    70 

    71 // ---------------------------------------------------------------------------

    72 // Destructor

    73 // ---------------------------------------------------------------------------

    74 //

    75 CBCTestDomM3gNodeCase::~CBCTestDomM3gNodeCase()

    76     {

    77     //M3GEnv::Release(); //Release env object. Only release one time,or panic.

    78     }

    79 

    80 // ---------------------------------------------------------------------------

    81 // Symbian 2nd Constructor

    82 // ---------------------------------------------------------------------------

    83 //

    84 void CBCTestDomM3gNodeCase::ConstructL()

    85     {

    86     BuildScriptL();

    87     }

    88 

    89 // ---------------------------------------------------------------------------

    90 // CBCTestDomM3gNodeCase::BuildScriptL

    91 // ---------------------------------------------------------------------------

    92 //

    93 void CBCTestDomM3gNodeCase::BuildScriptL()

    94     {

    95     const TInt scripts[] =

    96         {

    97         //outline13

    98         LeftCBA,

    99         Down,

   100         REP( LeftCBA, 2 ),

   101 

   102         //outline14

   103         LeftCBA,

   104         Down,

   105         LeftCBA,

   106         REP( Down, 1 ),

   107         LeftCBA,

   108 

   109         //outline15

   110         LeftCBA,

   111         Down,

   112         LeftCBA,

   113         REP( Down, 2 ),

   114         LeftCBA,

   115 

   116         //outline16

   117         LeftCBA,

   118         Down,

   119         LeftCBA,

   120         REP( Down, 3 ),

   121         LeftCBA,

   122 

   123         //outline17

   124         LeftCBA,

   125         Down,

   126         LeftCBA,

   127         REP( Down, 4 ),

   128         LeftCBA,

   129 

   130         //outline18

   131         LeftCBA,

   132         Down,

   133         LeftCBA,

   134         REP( Down, 5 ),

   135         LeftCBA,

   136 

   137         //outline19

   138         LeftCBA,

   139         Down,

   140         LeftCBA,

   141         REP( Down, 6 ),

   142         LeftCBA,

   143 

   144         //outline20

   145         LeftCBA,

   146         Down,

   147         LeftCBA,

   148         REP( Down, 7 ),

   149         LeftCBA,

   150 

   151         };

   152     AddTestScriptL( scripts, sizeof( scripts ) / sizeof( TInt ) );

   153     }

   154 

   155 // ---------------------------------------------------------------------------

   156 // CBCTestDomM3gNodeCase::RunL

   157 // ---------------------------------------------------------------------------

   158 //

   159 void CBCTestDomM3gNodeCase::RunL( TInt aCmd )

   160     {

   161     if ( ( aCmd < EBCTestCmdOutline13 ) || ( aCmd > EBCTestCmdOutline20 ) )

   162         {

   163         return;

   164         }

   165     switch ( aCmd )

   166         {

   167         case EBCTestCmdOutline13:

   168             TestRM3GTransformableL();

   169             break;

   170         case EBCTestCmdOutline14:

   171             TestRM3GNodeL();

   172             break;

   173         case EBCTestCmdOutline15:

   174             TestRM3GCameraL();

   175             break;

   176         case EBCTestCmdOutline16:

   177             TestRM3GGroupL();

   178             break;

   179         case EBCTestCmdOutline17:

   180             TestRM3GLightL();

   181             break;

   182         case EBCTestCmdOutline18:

   183             TestRM3MeshL();

   184             TestRM3GMorphingMeshL();

   185             TestRM3GSkinnedMeshL();

   186             break;

   187         case EBCTestCmdOutline19:

   188             TestRM3GSpriteL();

   189             break;

   190         case EBCTestCmdOutline20:

   191             TestRM3GWorldL();

   192             break;

   193         default:

   194             break;

   195         }

   196     }

   197 

   198 // ---------------------------------------------------------------------------

   199 // CBCTestDomM3gNodeCase::TestRM3GTransformableL

   200 // ---------------------------------------------------------------------------

   201 //

   202 void CBCTestDomM3gNodeCase::TestRM3GTransformableL()

   203     {

   204     //Note:RM3GLight is a sub class of RM3GNode,

   205     //RM3GNode is a sub class of RM3GTransformable.

   206     RM3GLight m3gLight;

   207     CleanupClosePushL( m3gLight );

   208     m3gLight.OpenL();

   209 

   210     TM3GMatrix transform;

   211     m3gLight.GetCompositeTransform( transform );

   212     _LIT( KRM3GTransformable, "RM3GTransformable::RM3GTransformable()" );

   213     AssertTrueL( ETrue, KRM3GTransformable );

   214 

   215     TM3GVector4 angleAxis;

   216     m3gLight.GetOrientation( angleAxis );

   217     _LIT( KRM3GTformableGetOrientation,

   218         "RM3GTransformable::GetOrientation()" );

   219     AssertTrueL( ETrue, KRM3GTformableGetOrientation );

   220 

   221     TM3GVector3 translation;

   222     m3gLight.GetScale( translation );

   223     _LIT( KRM3GTformableGetScale, "RM3GTransformable::GetScale()" );

   224     AssertTrueL( ETrue, KRM3GTformableGetScale );

   225 

   226     m3gLight.GetTransform( transform );

   227     _LIT( KRM3GTformableGetTransform,

   228         "RM3GTransformable::GetTransform()" );

   229     AssertTrueL( ETrue, KRM3GTformableGetTransform );

   230 

   231     m3gLight.GetTranslation( translation );

   232     _LIT( KRM3GTformableGetTranslation,

   233         "RM3GTransformable::GetTranslation()" );

   234     AssertTrueL( ETrue, KRM3GTformableGetTranslation );

   235 

   236     TReal32 angle = 1.0;

   237     TReal32 x = 1.0;

   238     TReal32 y = 1.0;

   239     TReal32 z = 1.0;

   240     m3gLight.PostRotate( angle, x, y, z );

   241     _LIT( KRM3GTformablePostRotate, "RM3GTransformable::PostRotate()" );

   242     AssertTrueL( ETrue, KRM3GTformablePostRotate );

   243 

   244     m3gLight.PreRotate( angle, x, y, z );

   245     _LIT( KRM3GTformablePreRotate, "RM3GTransformable::PreRotate()" );

   246     AssertTrueL( ETrue, KRM3GTformablePreRotate );

   247 

   248     m3gLight.Scale( x, y, z );

   249     _LIT( KRM3GTformableScale, "RM3GTransformable::Scale()" );

   250     AssertTrueL( ETrue, KRM3GTformableScale );

   251 

   252     m3gLight.SetOrientation( angle, x, y, z );

   253     _LIT( KRM3GTformableSetOrientation,

   254         "RM3GTransformable::SetOrientation()" );

   255     AssertTrueL( ETrue, KRM3GTformableSetOrientation );

   256 

   257     m3gLight.SetScale( x, y, z );

   258     _LIT( KRM3GTformableSetScale, "RM3GTransformable::SetScale()" );

   259     AssertTrueL( ETrue, KRM3GTformableSetScale );

   260 

   261     m3gLight.SetTransform( transform );

   262     _LIT( KRM3GTformableSetTransform, "RM3GTransformable::SetTransform()" );

   263     AssertTrueL( ETrue, KRM3GTformableSetTransform );

   264 

   265     m3gLight.SetTranslation( x, y, z );

   266     _LIT( KRM3GTformableSetTranslation,

   267         "RM3GTransformable::SetTranslation()" );

   268     AssertTrueL( ETrue, KRM3GTformableSetTranslation );

   269 

   270     m3gLight.Translate( x, y, z );

   271     _LIT( KRM3GTformableTranslate, "RM3GTransformable::Translate()" );

   272     AssertTrueL( ETrue, KRM3GTformableTranslate );

   273 

   274     CleanupStack::PopAndDestroy();// m3gLight

   275     }

   276 

   277 // ---------------------------------------------------------------------------

   278 // CBCTestDomM3gNodeCase::TestRM3GNodeL

   279 // ---------------------------------------------------------------------------

   280 //

   281 void CBCTestDomM3gNodeCase::TestRM3GNodeL()

   282     {

   283     //Note:RM3GLight is a sub class of RM3GNode,

   284     RM3GLight m3gLight;

   285     CleanupClosePushL( m3gLight );

   286     m3gLight.OpenL();

   287 

   288     m3gLight.Align( m3gLight );

   289     _LIT( KRM3GNodeAlign, "RM3GNode::Align()" );

   290     AssertTrueL( ETrue, KRM3GNodeAlign );

   291 

   292     TReal factor = m3gLight.AlphaFactor();

   293     _LIT( KRM3GNodeAlphaFactor, "RM3GNode::AlphaFactor()" );

   294     AssertTrueL( ETrue, KRM3GNodeAlphaFactor );

   295 

   296     RM3GNode m3gNode = m3gLight.Parent();

   297     _LIT( KRM3GNodeParent, "RM3GNode::Parent()" );

   298     AssertTrueL( ETrue, KRM3GNodeParent );

   299     CleanupClosePushL( m3gNode );

   300 

   301     TInt scope = m3gLight.Scope();

   302     _LIT( KRM3GNodeScope, "RM3GNode::Scope()" );

   303     AssertTrueL( ETrue, KRM3GNodeScope );

   304 

   305     TM3GMatrix transform;

   306     RM3GLight m3gLightPara;

   307     CleanupClosePushL( m3gLightPara );

   308     m3gLightPara.OpenL();

   309     TBool transformFlag = m3gLight.GetTransformTo( m3gLightPara, transform );

   310     _LIT( KRM3GNodeGetTransformTo, "RM3GNode::GetTransformTo()" );

   311     AssertTrueL( ETrue, KRM3GNodeGetTransformTo );

   312 

   313     TBool pickingFlag = m3gLight.IsPickingEnabled();

   314     _LIT( KRM3GNodeIsPickingEnabled, "RM3GNode::IsPickingEnabled()" );

   315     AssertTrueL( ETrue, KRM3GNodeIsPickingEnabled );

   316 

   317     TBool renderingFlag = m3gLight.IsRenderingEnabled();

   318     _LIT( KRM3GNodeIsRenderingEnabled, "RM3GNode::IsRenderingEnabled()" );

   319     AssertTrueL( ETrue, KRM3GNodeIsRenderingEnabled );

   320 

   321     RM3GLight m3gLightZRef;

   322     CleanupClosePushL( m3gLightZRef );

   323     m3gLightZRef.OpenL();

   324     RM3GLight m3gLightYRef;

   325     CleanupClosePushL( m3gLightYRef );

   326     m3gLightYRef.OpenL();

   327     m3gLight.SetAlignment( m3gLightZRef,

   328                            RM3GNode::EZAxis,

   329                            m3gLightYRef,

   330                            RM3GNode::EYAxis );

   331     _LIT( KRM3GNodeSetAlignment, "RM3GNode::SetAlignment()" );

   332     AssertTrueL( ETrue, KRM3GNodeSetAlignment );

   333 

   334     m3gLight.SetAlphaFactor( factor );

   335     _LIT( KRM3GNodeSetAlphaFactor, "RM3GNode::SetAlphaFactor()" );

   336     AssertTrueL( ETrue, KRM3GNodeSetAlphaFactor );

   337 

   338     m3gLight.SetPickingEnable( pickingFlag );

   339     _LIT( KRM3GNodeSetPickingEnable, "RM3GNode::SetPickingEnable()" );

   340     AssertTrueL( ETrue, KRM3GNodeSetPickingEnable );

   341 

   342     m3gLight.SetRenderingEnable( renderingFlag );

   343     _LIT( KRM3GNodeSetRenderingEnable, "RM3GNode::SetRenderingEnable()" );

   344     AssertTrueL( ETrue, KRM3GNodeSetRenderingEnable );

   345 

   346     m3gLight.SetScope( scope );

   347     _LIT( KRM3GNodeSetScope, "RM3GNode::SetScope()" );

   348     AssertTrueL( ETrue, KRM3GNodeSetScope );

   349 

   350     // m3gLight, m3gNode, m3gLightPara, m3gLightZRef, m3gLightYRef

   351     CleanupStack::PopAndDestroy( 5 );

   352     }

   353 

   354 // ---------------------------------------------------------------------------

   355 // CBCTestDomM3gNodeCase::TestRM3GLightL

   356 // ---------------------------------------------------------------------------

   357 //

   358 void CBCTestDomM3gNodeCase::TestRM3GLightL()

   359     {

   360     RM3GLight m3gLight;

   361     RM3GLight m3gCastLight;

   362     CleanupClosePushL( m3gLight );

   363     CleanupClosePushL( m3gCastLight );

   364     _LIT( KRM3GLight, "RM3GLight::RM3GLight()" );

   365     AssertTrueL( ETrue, KRM3GLight );

   366 

   367     m3gLight.OpenL();

   368     m3gCastLight.OpenL();

   369     _LIT( KRM3GLightOpenL, "RM3GLight::OpenL()" );

   370     AssertTrueL( ETrue, KRM3GLightOpenL );

   371 

   372     TInt lightColor = m3gLight.Color();

   373     _LIT( KRM3GLightColor, "RM3GLight::Color()" );

   374     AssertTrueL( ETrue, KRM3GLightColor );

   375 

   376     TReal cAttenuation = m3gLight.ConstantAttenuation();

   377     _LIT( KRM3GLightConstantAttenuation,

   378         "RM3GLight::ConstantAttenuation()" );

   379     AssertTrueL( ETrue, KRM3GLightConstantAttenuation );

   380 

   381     TReal intensity = m3gLight.Intensity();

   382     _LIT( KRM3GLightIntensity, "RM3GLight::Intensity()" );

   383     AssertTrueL( ETrue, KRM3GLightIntensity );

   384 

   385     TReal lAttenuation = m3gLight.LinearAttenuation();

   386     _LIT( KRM3GLightLinearAttenuation,

   387         "RM3GLight::LinearAttenuation()" );

   388     AssertTrueL( ETrue, KRM3GLightLinearAttenuation );

   389 

   390     RM3GLight::TLightSource lightMode = m3gLight.Mode();

   391     _LIT( KRM3GLightMode, "RM3GLight::Mode()" );

   392     AssertTrueL( ETrue, KRM3GLightMode );

   393 

   394     TReal qAttenuation = m3gLight.QuadraticAttenuation();

   395     _LIT( KRM3GLightQuadraticAttenuation,

   396         "RM3GLight::QuadraticAttenuation()" );

   397     AssertTrueL( ETrue, KRM3GLightQuadraticAttenuation );

   398 

   399     TReal angle = m3gLight.SpotAngle();

   400     _LIT( KRM3GLightSpotAngle, "RM3GLight::SpotAngle()" );

   401     AssertTrueL( ETrue, KRM3GLightSpotAngle );

   402 

   403     TReal exponent = m3gLight.SpotExponent();

   404     _LIT( KRM3GLightSpotExponent, "RM3GLight::SpotExponent()" );

   405     AssertTrueL( ETrue, KRM3GLightSpotExponent );

   406 

   407     m3gLight.SetAttenuation( cAttenuation, lAttenuation, qAttenuation );

   408     _LIT( KRM3GLightSetAttenuation, "RM3GLight::SetAttenuation()" );

   409     AssertTrueL( ETrue, KRM3GLightSetAttenuation );

   410 

   411     m3gLight.SetColor( lightColor );

   412     _LIT( KRM3GLightSetColor, "RM3GLight::SetColor()" );

   413     AssertTrueL( ETrue, KRM3GLightSetColor );

   414 

   415     m3gLight.SetIntensity( intensity );

   416     _LIT( KRM3GLightSetIntensity, "RM3GLight::SetIntensity()" );

   417     AssertTrueL( ETrue, KRM3GLightSetIntensity );

   418 

   419     m3gLight.SetMode( lightMode );

   420     _LIT( KRM3GLightSetMode, "RM3GLight::SetMode()" );

   421     AssertTrueL( ETrue, KRM3GLightSetMode );

   422 

   423     m3gLight.SetSpotAngle( angle );

   424     _LIT( KRM3GLightSetSpotAngle, "RM3GLight::SetSpotAngle()" );

   425     AssertTrueL( ETrue, KRM3GLightSetSpotAngle );

   426 

   427     m3gLight.SetSpotExponent( exponent );

   428     _LIT( KRM3GLightSetSpotExponent, "RM3GLight::SetSpotExponent()" );

   429     AssertTrueL( ETrue, KRM3GLightSetSpotExponent );

   430 

   431     m3gLight.Cast( m3gCastLight );

   432     _LIT( KRM3GLightCast, "RM3GLight::Cast()" );

   433     AssertTrueL( ETrue, KRM3GLightCast );

   434 

   435     CleanupStack::PopAndDestroy( 2 );// m3gLight, m3gCastLight

   436 

   437     }

   438 

   439 // ---------------------------------------------------------------------------

   440 // CBCTestDomM3gNodeCase::TestRM3GCameraL

   441 // ---------------------------------------------------------------------------

   442 //

   443 void CBCTestDomM3gNodeCase::TestRM3GCameraL()

   444     {

   445     RM3GCamera m3gCamera;

   446     CleanupClosePushL( m3gCamera );

   447     _LIT( KRM3GCamera, "RM3GCamera::RM3GCamera()" );

   448     AssertTrueL( ETrue, KRM3GCamera );

   449 

   450     m3gCamera.OpenL();

   451     _LIT( KRM3GCameraOpenL, "RM3GCamera::OpenL()" );

   452     AssertTrueL( ETrue, KRM3GCameraOpenL );

   453 

   454     TM3GProjectionParams projectionParams;

   455     m3gCamera.Projection( projectionParams );

   456     _LIT( KRM3GCameraProjection, "RM3GCamera::Projection()" );

   457     AssertTrueL( ETrue, KRM3GCameraProjection );

   458 

   459     TM3GMatrix m3gMatrix;

   460     m3gCamera.Projection( m3gMatrix );

   461     _LIT( KRM3GCameraProjectionM, "RM3GCamera::Projection()" );

   462     AssertTrueL( ETrue, KRM3GCameraProjectionM );

   463 

   464     m3gCamera.SetGeneric( m3gMatrix );

   465     _LIT( KRM3GCameraSetGeneric, "RM3GCamera::SetGeneric()" );

   466     AssertTrueL( ETrue, KRM3GCameraSetGeneric );

   467 

   468     TReal32 fovy = 1.0;

   469     TReal32 aspectRatio = 1.0;

   470     TReal32 near = 1.0;

   471     TReal32 far = 2.0;

   472     m3gCamera.SetParallel( fovy, aspectRatio, near, far );

   473     _LIT( KRM3GCameraSetParallel, "RM3GCamera::SetParallel()" );

   474     AssertTrueL( ETrue, KRM3GCameraSetParallel );

   475 

   476     m3gCamera.SetPerspective( fovy, aspectRatio, near, far );

   477     _LIT( KRM3GCameraSetPerspective, "RM3GCamera::SetPerspective()" );

   478     AssertTrueL( ETrue, KRM3GCameraSetPerspective );

   479 

   480     m3gCamera.Cast( m3gCamera );

   481     _LIT( KRM3GCameraCast, "RM3GCamera::Cast()" );

   482     AssertTrueL( ETrue, KRM3GCameraCast );

   483 

   484     CleanupStack::PopAndDestroy();// m3gCamera

   485     }

   486 

   487 // ---------------------------------------------------------------------------

   488 // CBCTestDomM3gNodeCase::TestRM3GGroupL

   489 // ---------------------------------------------------------------------------

   490 //

   491 void CBCTestDomM3gNodeCase::TestRM3GGroupL()

   492     {

   493     RM3GGroup m3gGroup;

   494     CleanupClosePushL( m3gGroup );

   495     _LIT( KRM3GGroup, "RM3GGroup::RM3GGroup()" );

   496     AssertTrueL( ETrue, KRM3GGroup );

   497 

   498     m3gGroup.OpenL();

   499     _LIT( KRM3GGroupOpenL, "RM3GGroup::OpenL()" );

   500     AssertTrueL( ETrue, KRM3GGroupOpenL );

   501 

   502     RM3GWorld m3gWorld;

   503     CleanupClosePushL( m3gWorld );

   504     m3gWorld.OpenL();

   505     m3gGroup.AddChild( m3gWorld );

   506     _LIT( KRM3GGroupAddChild, "RM3GGroup::AddChild()" );

   507     AssertTrueL( ETrue, KRM3GGroupAddChild );

   508 

   509     TInt index = 0;

   510     RM3GNode childNode = m3gGroup.Child( index );

   511     CleanupClosePushL( childNode );

   512     _LIT( KRM3GGroupChild, "RM3GGroup::Child()" );

   513     AssertTrueL( ETrue, KRM3GGroupChild );

   514 

   515     m3gGroup.ChildCount();

   516     _LIT( KRM3GGroupChildCount, "RM3GGroup::ChildCount()" );

   517     AssertTrueL( ETrue, KRM3GGroupChildCount );

   518 

   519     TInt scope = 10;

   520     TReal32 x = 0;

   521     TReal32 y = 0;

   522     RM3GCamera m3gCamera;

   523     CleanupClosePushL( m3gCamera );

   524     m3gCamera.OpenL();

   525     TM3GRayIntersection ri;

   526     m3gGroup.Pick( scope, x, y, m3gCamera, ri );

   527     _LIT( KRM3GGroupPick, "RM3GGroup::Pick()" );

   528     AssertTrueL( ETrue, KRM3GGroupPick );

   529 

   530     TM3GRay m3gRay;

   531     TM3GRayIntersection rayIntersection;

   532     m3gGroup.Pick( scope, m3gRay, rayIntersection );

   533     _LIT( KRM3GGroupPickCopy, "RM3GGroup::Pick()" );

   534     AssertTrueL( ETrue, KRM3GGroupPickCopy );

   535 

   536     m3gGroup.RemoveChild( childNode );

   537     _LIT( KRM3GGroupRemoveChild, "RM3GGroup::RemoveChild()" );

   538     AssertTrueL( ETrue, KRM3GGroupRemoveChild );

   539 

   540     m3gGroup.Cast( m3gGroup );

   541     _LIT( KRM3GGroupCast, "RM3GGroup::Cast()" );

   542     AssertTrueL( ETrue, KRM3GGroupCast );

   543 

   544     // m3gGroup, childNode, m3gCamera, m3gWorld

   545     CleanupStack::PopAndDestroy( 4 );

   546     }

   547 

   548 // ---------------------------------------------------------------------------

   549 // CBCTestDomM3gNodeCase::TestRM3GWorldL

   550 // ---------------------------------------------------------------------------

   551 //

   552 void CBCTestDomM3gNodeCase::TestRM3GWorldL()

   553     {

   554     RM3GWorld m3gWorld;

   555     CleanupClosePushL( m3gWorld );

   556     _LIT( KRM3GWorld, "RM3GWorld::RM3GWorld()" );

   557     AssertTrueL( ETrue, KRM3GWorld );

   558 

   559     m3gWorld.OpenL();

   560     _LIT( KRM3GWorldOpenL, "RM3GWorld::OpenL()" );

   561     AssertTrueL( ETrue, KRM3GWorldOpenL );

   562 

   563     RM3GCamera camera = m3gWorld.ActiveCamera();

   564     _LIT( KRM3GWorldActiveCamera, "RM3GWorld::ActiveCamera()" );

   565     AssertTrueL( ETrue, KRM3GWorldActiveCamera );

   566     CleanupClosePushL( camera );

   567 

   568     RM3GBackground backGround = m3gWorld.Background();

   569     _LIT( KRM3GWorldBackground, "RM3GWorld::Background()" );

   570     AssertTrueL( ETrue, KRM3GWorldBackground );

   571     CleanupClosePushL( backGround );

   572 

   573     m3gWorld.SetActiveCamera( camera );

   574     _LIT( KRM3GWorldSetActiveCamera, "RM3GWorld::SetActiveCamera()" );

   575     AssertTrueL( ETrue, KRM3GWorldSetActiveCamera );

   576 

   577     m3gWorld.SetBackground( backGround );

   578     _LIT( KRM3GWorldSetBackground, "RM3GWorld::SetBackground()" );

   579     AssertTrueL( ETrue, KRM3GWorldSetBackground );

   580 

   581     m3gWorld.Cast( m3gWorld );

   582     _LIT( KRM3GWorldCast, "RM3GWorld::Cast()" );

   583     AssertTrueL( ETrue, KRM3GWorldCast );

   584 

   585     CleanupStack::PopAndDestroy( 3 );// m3gWorld, backGround, camera

   586     }

   587 

   588 // ---------------------------------------------------------------------------

   589 // CBCTestDomM3gNodeCase::TestRM3GSpriteL

   590 // ---------------------------------------------------------------------------

   591 //

   592 void CBCTestDomM3gNodeCase::TestRM3GSpriteL()

   593     {

   594     RM3GSprite m3gSprite;

   595     CleanupClosePushL( m3gSprite );

   596     _LIT( KRM3GSprite, "RM3GSprite::RM3GSprite()" );

   597     AssertTrueL( ETrue, KRM3GSprite );

   598 

   599     RM3GAppearance m3gAppearance;

   600     CleanupClosePushL( m3gAppearance );

   601     m3gAppearance.OpenL();

   602 

   603     RM3GImage m3gImage;

   604     CleanupClosePushL( m3gImage );

   605     TInt imageWidth = 20;

   606     TInt imageHeight = 20;

   607     TInt flag = 1;

   608     m3gImage.OpenL( RM3GImage::ELuminance,

   609                     imageWidth,

   610                     imageHeight,

   611                     flag );

   612     TBool scaled = ETrue;

   613     m3gSprite.OpenL( m3gAppearance, m3gImage, scaled );

   614     _LIT( KRM3GSpriteOpenL, "RM3GSprite::OpenL()" );

   615     AssertTrueL( ETrue, KRM3GSpriteOpenL );

   616 

   617     RM3GAppearance m3gAppearanceReturn = m3gSprite.Appearance();

   618     CleanupClosePushL( m3gAppearanceReturn );

   619     _LIT( KRM3GSpriteAppearance, "RM3GSprite::Appearance()" );

   620     AssertTrueL( ETrue, KRM3GSpriteAppearance );

   621 

   622     TInt cHeight = m3gSprite.CropHeight();

   623     _LIT( KRM3GSpriteCropHeight, "RM3GSprite::CropHeight()" );

   624     AssertTrueL( ETrue, KRM3GSpriteCropHeight );

   625 

   626     TInt cWidth = m3gSprite.CropWidth();

   627     _LIT( KRM3GSpriteCropWidth, "RM3GSprite::CropWidth()" );

   628     AssertTrueL( ETrue, KRM3GSpriteCropWidth );

   629 

   630     TInt cX = m3gSprite.CropX();

   631     _LIT( KRM3GSpriteCropX, "RM3GSprite::CropX()" );

   632     AssertTrueL( ETrue, KRM3GSpriteCropX );

   633 

   634     TInt cY = m3gSprite.CropY();

   635     _LIT( KRM3GSpriteCropY, "RM3GSprite::CropY()" );

   636     AssertTrueL( ETrue, KRM3GSpriteCropY );

   637 

   638     RM3GImage m3gImageReturn = m3gSprite.Image();

   639     CleanupClosePushL( m3gImageReturn );

   640     _LIT( KRM3GSpriteImage, "RM3GSprite::Image()" );

   641     AssertTrueL( ETrue, KRM3GSpriteImage );

   642 

   643     scaled = m3gSprite.IsScaled();

   644     _LIT( KRM3GSpriteIsScaled, "RM3GSprite::IsScaled()" );

   645     AssertTrueL( ETrue, KRM3GSpriteIsScaled );

   646 

   647     m3gSprite.SetAppearance( m3gAppearanceReturn );

   648     _LIT( KRM3GSpriteSetAppearance, "RM3GSprite::SetAppearance()" );

   649     AssertTrueL( ETrue, KRM3GSpriteSetAppearance );

   650 

   651     m3gSprite.SetCrop(cHeight, cWidth, cX, cY );

   652     _LIT( KRM3GSpriteSetCrop, "RM3GSprite::SetCrop()" );

   653     AssertTrueL( ETrue, KRM3GSpriteSetCrop );

   654 

   655     m3gSprite.SetImage( m3gImageReturn );

   656     _LIT( KRM3GSpriteSetImage, "RM3GSprite::SetImage()" );

   657     AssertTrueL( ETrue, KRM3GSpriteSetImage );

   658 

   659     m3gSprite.Cast( m3gSprite );

   660     _LIT( KRM3GSpriteCast, "RM3GSprite::Cast()" );

   661     AssertTrueL( ETrue, KRM3GSpriteCast );

   662 

   663     // m3gSprite, m3gAppearance, m3gImage, m3gAppearanceReturn, m3gImageReturn

   664     CleanupStack::PopAndDestroy( 5 );

   665     }

   666 

   667 // ---------------------------------------------------------------------------

   668 // CBCTestDomM3gNodeCase::TestRM3MeshL

   669 // ---------------------------------------------------------------------------

   670 //

   671 void CBCTestDomM3gNodeCase::TestRM3MeshL()

   672     {

   673     RM3GMesh m3gMesh;

   674     CleanupClosePushL( m3gMesh );

   675     _LIT( KRM3Mesh, "RM3Mesh::RM3Mesh()" );

   676     AssertTrueL( ETrue, KRM3Mesh );

   677 

   678     RM3GIndexBuffer m3gIndexBuffer;

   679     CleanupClosePushL( m3gIndexBuffer );

   680 

   681     TInt stripLengths[] = { 4, 5, 6, 7 };

   682     TInt stripLengthCount = 4;

   683     TInt firstIndex = 0;

   684     m3gIndexBuffer.OpenL( firstIndex, stripLengths, stripLengthCount );

   685     _LIT( KRM3GIndexBufferOpenL, "RM3GIndexBuffer::OpenL()" );

   686     AssertTrueL( ETrue, KRM3GIndexBufferOpenL );

   687 

   688     RM3GVertexBuffer m3gVertexBuffer;

   689     RM3GAppearance m3gAppearance;

   690     CleanupClosePushL( m3gVertexBuffer );

   691     CleanupClosePushL( m3gAppearance );

   692 

   693     m3gVertexBuffer.OpenL();

   694     m3gAppearance.OpenL();

   695 

   696     m3gMesh.OpenL( m3gVertexBuffer, m3gIndexBuffer, m3gAppearance );

   697     _LIT( KRM3MeshOpenL, "RM3Mesh::OpenL()" );

   698     AssertTrueL( ETrue, KRM3MeshOpenL );

   699 

   700     RArray<RM3GIndexBuffer> indexBuffers;

   701     RArray<RM3GAppearance> appearances;

   702     CleanupClosePushL( indexBuffers );

   703     CleanupClosePushL( appearances );

   704     RM3GMesh m3gMeshCopy;

   705     CleanupClosePushL( m3gMeshCopy );

   706     m3gMeshCopy.OpenL( m3gVertexBuffer, indexBuffers, appearances );

   707     _LIT( KRM3MeshOpenLOver, "RM3Mesh::OpenL()" );

   708     AssertTrueL( ETrue, KRM3MeshOpenLOver );

   709 

   710     TInt index = 0;

   711     RM3GAppearance appearanceReturn = m3gMesh.Appearance( index );

   712     _LIT( KRM3MeshAppearance, "RM3Mesh::Appearance()" );

   713     AssertTrueL( ETrue, KRM3MeshAppearance );

   714     CleanupClosePushL( appearanceReturn );

   715 

   716     RM3GIndexBuffer indexBufferReturn = m3gMesh.IndexBuffer( index );

   717     CleanupClosePushL( indexBufferReturn );

   718     _LIT( KRM3MeshIndexBuffer, "RM3Mesh::IndexBuffer()" );

   719     AssertTrueL( ETrue, KRM3MeshIndexBuffer );

   720 

   721     TInt submeshCount = m3gMesh.SubmeshCount();

   722     _LIT( KRM3MeshSubmeshCount, "RM3Mesh::SubmeshCount()" );

   723     AssertTrueL( ETrue, KRM3MeshSubmeshCount );

   724 

   725     RM3GVertexBuffer vertexBufferRetrun = m3gMesh.VertexBuffer();

   726     CleanupClosePushL( vertexBufferRetrun );

   727     _LIT( KRM3MeshVertexBuffer, "RM3Mesh::VertexBuffer()" );

   728     AssertTrueL( ETrue, KRM3MeshVertexBuffer );

   729 

   730     m3gMesh.SetAppearance( index, appearanceReturn );

   731     _LIT( KRM3MeshSetAppearance, "RM3Mesh::SetAppearance()" );

   732     AssertTrueL( ETrue, KRM3MeshSetAppearance );

   733 

   734     m3gMesh.Cast( m3gMesh );

   735     _LIT( KRM3MeshCast, "RM3Mesh::Cast()" );

   736     AssertTrueL( ETrue, KRM3MeshCast );

   737 

   738     //m3gMesh, m3gIndexBuffer, m3gVertexBuffer,

   739     //m3gAppearance, indexBuffers, appearances, m3gMeshCopy,

   740     //appearanceReturn, indexBufferReturn, vertexBufferRetrun

   741     CleanupStack::PopAndDestroy( 10 );

   742     }

   743 

   744 // ---------------------------------------------------------------------------

   745 // CBCTestDomM3gNodeCase::TestRM3GMorphingMeshL

   746 // ---------------------------------------------------------------------------

   747 //

   748 void CBCTestDomM3gNodeCase::TestRM3GMorphingMeshL()

   749     {

   750     #ifdef __WINSCW__

   751     RM3GMorphingMesh m3gMorphingMesh;

   752     CleanupClosePushL( m3gMorphingMesh );

   753     _LIT( KRM3GMMesh, "RM3GMorphingMesh::RM3GMorphingMesh()" );

   754     AssertTrueL( ETrue, KRM3GMMesh );

   755 

   756     RM3GIndexBuffer m3gIndexBuffer;

   757     CleanupClosePushL( m3gIndexBuffer );

   758     TInt stripLengths[] = { 4, 5, 6, 7 };

   759     TInt stripLengthCount = 4;

   760     TInt firstIndex = 0;

   761     m3gIndexBuffer.OpenL( firstIndex, stripLengths, stripLengthCount );

   762 

   763     RM3GVertexBuffer m3gVertexBuffer;

   764     RM3GAppearance m3gAppearance;

   765     CleanupClosePushL( m3gVertexBuffer );

   766     CleanupClosePushL( m3gAppearance );

   767 

   768     m3gVertexBuffer.OpenL();

   769     m3gAppearance.OpenL();

   770 

   771     RArray<RM3GVertexBuffer> targets;

   772     CleanupClosePushL( targets );

   773     targets.Append( m3gVertexBuffer );

   774 

   775     m3gMorphingMesh.OpenL( m3gVertexBuffer,

   776                            targets,

   777                            m3gIndexBuffer,

   778                            m3gAppearance );

   779     _LIT( KRM3GMMeshOpenL, "RM3GMorphingMesh::OpenL()" );

   780     AssertTrueL( ETrue, KRM3GMMeshOpenL );

   781 

   782     m3gMorphingMesh.Cast( m3gMorphingMesh );

   783     _LIT( KRM3GMMeshCast, "RM3GMorphingMesh::Cast()" );

   784     AssertTrueL( ETrue, KRM3GMMeshCast );

   785 

   786     RM3GMorphingMesh m3gMorphingMeshCopy;

   787     CleanupClosePushL( m3gMorphingMeshCopy );

   788 

   789     RArray<RM3GIndexBuffer> submeshes;

   790     RArray<RM3GAppearance> appearances;

   791     CleanupClosePushL( submeshes );

   792     CleanupClosePushL( appearances );

   793     submeshes.AppendL( m3gIndexBuffer );

   794     appearances.AppendL( m3gAppearance );

   795 

   796 

   797     m3gMorphingMeshCopy.OpenL( m3gVertexBuffer,

   798                                targets,

   799                                submeshes,

   800                                appearances );

   801     _LIT( KRM3GMMeshOpenLOver, "RM3GMorphingMesh::OpenL()" );

   802     AssertTrueL( ETrue, KRM3GMMeshOpenLOver );

   803 

   804     // m3gMorphingMesh, m3gIndexBuffer, m3gVertexBuffer,

   805     // m3gAppearance, targets, m3gMorphingMeshCopy,

   806     // submeshes, appearances

   807     CleanupStack::PopAndDestroy( 8 );

   808     #endif

   809     }

   810 

   811 // ---------------------------------------------------------------------------

   812 // CBCTestDomM3gNodeCase::TestRM3GSkinnedMeshL

   813 // ---------------------------------------------------------------------------

   814 //

   815 void CBCTestDomM3gNodeCase::TestRM3GSkinnedMeshL()

   816     {

   817     RM3GSkinnedMesh m3gSkinnedMesh;

   818     CleanupClosePushL( m3gSkinnedMesh );

   819     _LIT( KRM3GSMesh, "RM3GSkinnedMesh::RM3GSkinnedMesh()" );

   820     AssertTrueL( ETrue, KRM3GSMesh );

   821 

   822     RM3GGroup m3gGroup;

   823     CleanupClosePushL( m3gGroup );

   824     m3gGroup.OpenL();

   825 

   826     RM3GIndexBuffer m3gIndexBuffer;

   827     CleanupClosePushL( m3gIndexBuffer );

   828     TInt stripLengths[] = { 4, 5, 6, 7 };

   829     TInt stripLengthCount = 4;

   830     TInt firstIndex = 0;

   831     m3gIndexBuffer.OpenL( firstIndex, stripLengths, stripLengthCount );

   832 

   833     RM3GVertexBuffer m3gVertexBuffer;

   834     RM3GAppearance m3gAppearance;

   835     CleanupClosePushL( m3gVertexBuffer );

   836     CleanupClosePushL( m3gAppearance );

   837 

   838     m3gVertexBuffer.OpenL();

   839     m3gAppearance.OpenL();

   840 

   841     m3gSkinnedMesh.OpenL( m3gVertexBuffer,

   842                           m3gIndexBuffer,

   843                           m3gAppearance,

   844                           m3gGroup);

   845     _LIT( KRM3GSMeshOpenL, "RM3GSkinnedMesh::OpenL()" );

   846     AssertTrueL( ETrue, KRM3GSMeshOpenL );

   847 

   848     RM3GSkinnedMesh m3gSkinnedMeshCopy;

   849     CleanupClosePushL( m3gSkinnedMeshCopy );

   850 

   851     RArray<RM3GIndexBuffer> submeshes;

   852     RArray<RM3GAppearance> appearances;

   853     CleanupClosePushL( submeshes );

   854     CleanupClosePushL( appearances );

   855     submeshes.AppendL( m3gIndexBuffer );

   856     appearances.AppendL( m3gAppearance );

   857 

   858     TInt err;

   859     TRAP( err, m3gSkinnedMeshCopy.OpenL( m3gVertexBuffer,

   860                               submeshes,

   861                               appearances,

   862                               m3gGroup ) );

   863     _LIT( KRM3GSMeshOpenLOver, "RM3GSkinnedMesh::OpenL()" );

   864     AssertTrueL( ETrue, KRM3GSMeshOpenLOver );

   865 

   866     m3gSkinnedMesh.Cast( m3gSkinnedMesh );

   867     _LIT( KRM3GSMeshCast, "RM3GSkinnedMesh::Cast()" );

   868     AssertTrueL( ETrue, KRM3GSMeshCast );

   869 

   870     TInt weight = 10;

   871     TInt firstVertex = 0;

   872     TInt vertexCount = 2;

   873     m3gSkinnedMesh.AddTransform( m3gSkinnedMesh,

   874                                  weight,

   875                                  firstVertex,

   876                                  vertexCount );

   877     _LIT( KRM3GSMeshAddTransform, "RM3GSkinnedMesh::AddTransform()" );

   878     AssertTrueL( ETrue, KRM3GSMeshAddTransform );

   879 

   880     RM3GGroup groupReturn = m3gSkinnedMesh.Skeleton();

   881     CleanupClosePushL( groupReturn );

   882     _LIT( KRM3GSMeshSkeleton, "RM3GSkinnedMesh::Skeleton()" );

   883     AssertTrueL( ETrue, KRM3GSMeshSkeleton );

   884 

   885     // m3gSkinnedMesh, m3gGroup, m3gIndexBuffer,

   886     // m3gVertexBuffer, m3gAppearance, m3gSkinnedMeshCopy,

   887     // submeshes, appearances, groupReturn

   888     CleanupStack::PopAndDestroy( 9 );

   889     }