1 /*---------------------------------------------------------------------------*
2   Project:  NintendoWare
3   File:     gfx_Camera.cpp
4 
5   Copyright (C)2009-2010 Nintendo Co., Ltd./HAL Laboratory, Inc.  All rights reserved.
6 
7   These coded instructions, statements, and computer programs contain
8   proprietary information of Nintendo of America Inc. and/or Nintendo
9   Company Ltd., and are protected by Federal copyright law.  They may
10   not be disclosed to third parties or copied or duplicated in any form,
11   in whole or in part, without the prior written consent of Nintendo.
12 
13   $Revision: 29649 $
14  *---------------------------------------------------------------------------*/
15 
16 #include "precompiled.h"
17 
18 #include <nw/gfx/res/gfx_ResCamera.h>
19 #include <nw/gfx/gfx_Camera.h>
20 #include <nw/gfx/gfx_ISceneVisitor.h>
21 #include <nw/gfx/gfx_AimTargetViewUpdater.h>
22 #include <nw/gfx/gfx_LookAtTargetViewUpdater.h>
23 #include <nw/gfx/gfx_RotateViewUpdater.h>
24 #include <nw/gfx/gfx_PerspectiveProjectionUpdater.h>
25 #include <nw/gfx/gfx_OrthoProjectionUpdater.h>
26 #include <nw/gfx/gfx_FrustumProjectionUpdater.h>
27 
28 namespace nw
29 {
30 namespace gfx
31 {
32 
33 NW_UT_RUNTIME_TYPEINFO_DEFINITION(Camera, TransformNode);
34 
35 //----------------------------------------
Camera(os::IAllocator * allocator,ResTransformNode resObj,const Camera::Description & description,GfxPtr<CameraViewUpdater> viewUpdater,GfxPtr<CameraProjectionUpdater> projectionUpdater,f32 wscale,bool isDynamic)36 Camera::Camera(
37     os::IAllocator* allocator,
38     ResTransformNode resObj,
39     const Camera::Description& description,
40     GfxPtr<CameraViewUpdater> viewUpdater,
41     GfxPtr<CameraProjectionUpdater> projectionUpdater,
42     f32 wscale,
43     bool isDynamic)
44 : TransformNode(
45     allocator,
46     resObj,
47     description),
48     m_ViewMatrix(math::MTX34::Identity()),
49     m_InverseViewMatrix(math::MTX34::Identity()),
50     m_ProjectionMatrix(math::MTX44::Identity()),
51     m_InverseProjectionMatrix(math::MTX44::Identity()),
52     m_TextureProjectionMatrix(math::MTX34::Identity()),
53     m_ViewUpdater(viewUpdater),
54     m_ProjectionUpdater(projectionUpdater),
55     m_AnimGroup(NULL),
56     m_OriginalValue(),
57     m_WScale(wscale),
58     m_IsDynamic(isDynamic)
59 {}
60 
61 //----------------------------------------
~Camera()62 Camera::~Camera()
63 {
64     ResCamera resCamera = ResDynamicCast<ResCamera>(this->GetResSceneNode());
65     if (this->m_IsDynamic && resCamera.IsValid())
66     {
67         this->GetAllocator().Free(resCamera.ptr());
68     }
69 
70     ResCameraDestroyer(&this->GetAllocator())(m_OriginalValue);
71     m_OriginalValue = ResCamera(NULL);
72 
73     ut::SafeDestroy(m_AnimGroup);
74 }
75 
76 //----------------------------------------
77 Result
CreateAnimGroup(os::IAllocator * allocator)78 Camera::CreateAnimGroup(os::IAllocator* allocator)
79 {
80     Result result = INITIALIZE_RESULT_OK;
81 
82     NW_ASSERT(m_OriginalValue.IsValid());
83 
84     if(!m_AnimBinding)
85     {
86         // DynamicBuilderを使用した場合は生成されない
87         return result;
88     }
89 
90     ResCamera resCamera = GetResCamera();
91     NW_ASSERT(resCamera.IsValid());
92 
93     NW_ASSERT(resCamera.GetAnimGroupsCount() == 1);
94     anim::ResAnimGroup resAnimGroup = resCamera.GetAnimGroups(0);
95 
96     NW_ASSERT(resAnimGroup.GetTargetType() == anim::ResGraphicsAnimGroup::TARGET_TYPE_CAMERA);
97 
98     AnimGroup* animGroup = AnimGroup::Builder()
99         .ResAnimGroup(resAnimGroup)
100         .SetSceneNode(this)
101         .UseOriginalValue(true) // TODO: 選択できる必要はある？
102         .Create(allocator);
103 
104     if (animGroup == NULL)
105     {
106         result |= Result::MASK_FAIL_BIT;
107     }
108 
109     NW_ENSURE_AND_RETURN(result);
110 
111     m_AnimGroup = animGroup;
112 
113     // 各メンバの参照解決
114     const int animMemberCount = m_AnimGroup->GetMemberCount();
115     for (int memberIdx = 0; memberIdx < animMemberCount; ++memberIdx)
116     {
117         anim::ResAnimGroupMember member = m_AnimGroup->GetResAnimGroupMember(memberIdx);
118 
119         void* object = GetAnimTargetObject(member);
120         m_AnimGroup->SetTargetObject(memberIdx, object);
121 
122         // TODO: アドレス算出もSetterに似た実装で行う？
123         if(member.GetObjectType() == anim::ResAnimGroupMember::OBJECT_TYPE_TRANSFORM &&
124             member.GetMemberType() == anim::ResTransformMember::MEMBER_TYPE_TRANSFORM)
125         {
126             m_AnimGroup->SetTargetPtr(memberIdx, &this->Transform());
127         }
128         else
129         {
130             u8* target = static_cast<u8*>(object);
131             target += member.GetMemberOffset();
132             m_AnimGroup->SetTargetPtr(memberIdx, target);
133         }
134 
135         m_AnimGroup->SetTargetObjectIndex(memberIdx, 0); // TODO: 要検討
136 
137         // OriginalValueを登録する
138         void* originalValue = NULL;
139         switch (member.GetObjectType())
140         {
141         case anim::ResAnimGroupMember::OBJECT_TYPE_TRANSFORM:
142             {
143                 switch (member.GetMemberType())
144                 {
145                 case anim::ResTransformMember::MEMBER_TYPE_TRANSFORM:
146                     originalValue = &m_OriginalTransform;
147                     break;
148                 default:
149                     NW_ASSERT(false);
150                 }
151             }
152             break;
153         case anim::ResAnimGroupMember::OBJECT_TYPE_VIEW_UPDATER:
154             {
155                 originalValue =
156                     ut::AddOffsetToPtr(m_OriginalValue.GetViewUpdater().ptr(), member.GetMemberOffset());
157             }
158             break;
159         case anim::ResAnimGroupMember::OBJECT_TYPE_PROJECTION_UPDATER:
160             {
161                 originalValue =
162                     ut::AddOffsetToPtr(m_OriginalValue.GetProjectionUpdater().ptr(), member.GetMemberOffset());
163             }
164             break;
165         default:
166             NW_ASSERT(false);
167         }
168 
169         NW_NULL_ASSERT(originalValue);
170         m_AnimGroup->SetOriginalValue(memberIdx, originalValue);
171     }
172 
173     m_AnimBinding->SetAnimGroup(0, m_AnimGroup);
174 
175     return result;
176 }
177 
178 //----------------------------------------
179 Camera*
Create(os::IAllocator * allocator)180 Camera::DynamicBuilder::Create(
181     os::IAllocator* allocator
182 )
183 {
184     NW_NULL_ASSERT(allocator);
185 
186     if (!this->m_ViewUpdater)
187     {
188         this->m_ViewUpdater.Reset(LookAtTargetViewUpdater::Create(allocator));
189     }
190 
191     if (!this->m_ProjectionUpdater)
192     {
193         this->m_ProjectionUpdater.Reset(PerspectiveProjectionUpdater::Create(allocator));
194     }
195 
196     // カメラを生成します。
197 
198     ResCameraData* resCamera =
199         AllocateAndFillN<ResCameraData>(allocator, sizeof(ResCameraData), 0);
200 
201     // カメラのリソースに、各Updaterを結び付けます。
202     resCamera->toViewUpdater.set_ptr(this->m_ViewUpdater->GetResource().ptr());
203     resCamera->toProjectionUpdater.set_ptr(this->m_ProjectionUpdater->GetResource().ptr());
204 
205     switch (this->m_ViewUpdater->GetResource().GetTypeInfo())
206     {
207         case ResAimTargetViewUpdater::TYPE_INFO:
208             resCamera->m_ViewType = ResCamera::VIEWTYPE_AIM;
209             break;
210         case ResLookAtTargetViewUpdater::TYPE_INFO:
211             resCamera->m_ViewType = ResCamera::VIEWTYPE_LOOKAT;
212             break;
213         case ResRotateViewUpdater::TYPE_INFO:
214             resCamera->m_ViewType = ResCamera::VIEWTYPE_ROTATE;
215             break;
216         default:
217             NW_ASSERT(false);
218     }
219 
220     switch (this->m_ProjectionUpdater->GetResource().GetTypeInfo())
221     {
222         case ResPerspectiveProjectionUpdater::TYPE_INFO:
223             resCamera->m_ProjectionType = ResCamera::PROJTYPE_PERSPECTIVE;
224             break;
225         case ResFrustumProjectionUpdater::TYPE_INFO:
226             resCamera->m_ProjectionType = ResCamera::PROJTYPE_FRUSTUM;
227             break;
228         case ResOrthoProjectionUpdater::TYPE_INFO:
229             resCamera->m_ProjectionType = ResCamera::PROJTYPE_ORTHO;
230             break;
231         default:
232             NW_ASSERT(false);
233     }
234 
235     //--------------------------------
236     // ResSceneObjectData のメンバ初期化
237     resCamera->typeInfo = ResCamera::TYPE_INFO;
238     resCamera->m_Header.revision = ResCamera::BINARY_REVISION;
239     resCamera->m_Header.signature = ResCamera::SIGNATURE;
240 
241     resCamera->m_UserDataDicCount = 0;
242     resCamera->toUserDataDic.set_ptr( NULL );
243 
244     const char* name = NULL; // 名前をつけるようになったら、GetMemorySize() を修正する必要あり。
245     resCamera->toName.set_ptr(AllocateAndCopyString(name, allocator, MAX_NAME_LENGTH));
246 
247     //--------------------------------
248     // ResSceneNodeData のメンバ初期化
249     resCamera->m_ChildrenTableCount = 0;
250     resCamera->toChildrenTable.set_ptr( NULL );
251     resCamera->m_AnimGroupsDicCount = 0;
252     resCamera->toAnimGroupsDic.set_ptr( NULL );
253 
254     //--------------------------------
255     // ResTransformNode のメンバ初期化
256     const math::VEC3 scale(1.0f, 1.0f, 1.0f);
257     const math::VEC3 rotate(0.0f, 0.0f, 0.0f);
258     const math::VEC3 translate(0.0f, 0.0f, 0.0f);
259     resCamera->m_Transform = math::Transform3(scale, rotate, translate);
260     resCamera->m_WorldMatrix = math::MTX34::Identity();
261     ResTransformNode(resCamera).SetBranchVisible(true);
262 
263     void* memory = allocator->Alloc(sizeof(Camera));
264     NW_NULL_ASSERT(memory);
265 
266     Camera* camera = new(memory) Camera(
267         allocator,
268         ResCamera(resCamera),
269         m_Description,
270         m_ViewUpdater,
271         m_ProjectionUpdater,
272         0.0f,
273         true);
274 
275     camera->Initialize(allocator);
276 
277     return camera;
278 }
279 
280 //----------------------------------------------------------
281 size_t
GetMemorySize(size_t alignment) const282 Camera::DynamicBuilder::GetMemorySize(size_t alignment) const
283 {
284     NW_ASSERT(this->m_Description.isFixedSizeMemory);
285 
286     os::MemorySizeCalculator size(alignment);
287 
288     ResCamera::ViewType viewType;
289     ResCamera::ProjType projType;
290 
291     // DynamicBuilder::Create
292     if (!this->m_ViewUpdater)
293     {
294         LookAtTargetViewUpdater::GetMemorySizeInternal(&size, true);
295         viewType = ResCamera::VIEWTYPE_LOOKAT;
296     }
297     else
298     {
299         switch (this->m_ViewUpdater->GetResource().GetTypeInfo())
300         {
301         case ResAimTargetViewUpdater::TYPE_INFO:
302             viewType = ResCamera::VIEWTYPE_AIM;
303             break;
304         case ResLookAtTargetViewUpdater::TYPE_INFO:
305             viewType = ResCamera::VIEWTYPE_LOOKAT;
306             break;
307         case ResRotateViewUpdater::TYPE_INFO:
308             viewType = ResCamera::VIEWTYPE_ROTATE;
309             break;
310         default:
311             NW_ASSERT(false);
312         }
313     }
314     if (!this->m_ProjectionUpdater)
315     {
316         PerspectiveProjectionUpdater::GetMemorySizeInternal(&size, true);
317         projType = ResCamera::PROJTYPE_PERSPECTIVE;
318     }
319     else
320     {
321         switch (this->m_ProjectionUpdater->GetResource().GetTypeInfo())
322         {
323         case ResPerspectiveProjectionUpdater::TYPE_INFO:
324             projType = ResCamera::PROJTYPE_PERSPECTIVE;
325             break;
326         case ResFrustumProjectionUpdater::TYPE_INFO:
327             projType = ResCamera::PROJTYPE_FRUSTUM;
328             break;
329         case ResOrthoProjectionUpdater::TYPE_INFO:
330             projType = ResCamera::PROJTYPE_ORTHO;
331             break;
332         default:
333             NW_ASSERT(false);
334         }
335     }
336 
337     size += sizeof(ResCameraData);
338     size += sizeof(Camera);
339 
340     // Camera::Initialize
341     TransformNode::GetMemorySizeForInitialize(
342         &size,
343         res::ResTransformNode(),
344         m_Description);
345 
346     // Camera::StoreOriginal
347     size += sizeof(ResCameraData);
348 
349     switch (viewType)
350     {
351     case ResCamera::VIEWTYPE_AIM:
352         size += sizeof(ResAimTargetViewUpdaterData);
353         break;
354     case ResCamera::VIEWTYPE_LOOKAT:
355         size += sizeof(ResLookAtTargetViewUpdaterData);
356         break;
357     case ResCamera::VIEWTYPE_ROTATE:
358         size += sizeof(ResRotateViewUpdaterData);
359         break;
360     default:
361         NW_ASSERT(false);
362     }
363 
364     switch (projType)
365     {
366     case ResCamera::PROJTYPE_PERSPECTIVE:
367         size += sizeof(ResPerspectiveProjectionUpdaterData);
368         break;
369     case ResCamera::PROJTYPE_FRUSTUM:
370         size += sizeof(ResFrustumProjectionUpdaterData);
371         break;
372     case ResCamera::PROJTYPE_ORTHO:
373         size += sizeof(ResOrthoProjectionUpdaterData);
374         break;
375     default:
376         NW_ASSERT(false);
377     }
378 
379     // Camera::CreateAnimGroup
380     // DynamicBuilder 使用時には何も行なわれない。
381 
382     return size.GetSizeWithPadding(alignment);
383 }
384 
385 //----------------------------------------
386 Camera*
Create(SceneNode * parent,ResSceneObject resource,const Camera::Description & description,os::IAllocator * allocator)387 Camera::Create(
388     SceneNode* parent,
389     ResSceneObject resource,
390     const Camera::Description& description,
391     os::IAllocator* allocator
392 )
393 {
394     NW_NULL_ASSERT(allocator);
395 
396     ResCamera resCamera = ResDynamicCast<ResCamera>(resource);
397     NW_ASSERT(resCamera.IsValid());
398     NW_ASSERT( internal::ResCheckRevision( resCamera ) );
399 
400     void* memory = allocator->Alloc(sizeof(Camera));
401     NW_NULL_ASSERT(memory);
402 
403     // リソースからビューアップデータを作成します。
404     ResCamera::ViewType viewType = resCamera.GetViewType();
405     ResCameraViewUpdater resViewUpdater = resCamera.GetViewUpdater();
406     NW_ASSERT(resViewUpdater.IsValid());
407     NW_ASSERT(viewType < ResCamera::VIEWTYPE_COUNT);
408     CameraViewUpdater* cameraView = NULL;
409     if (viewType == ResCamera::VIEWTYPE_AIM)
410     {
411         ResAimTargetViewUpdater resAimView(resViewUpdater.ptr());
412         AimTargetViewUpdater* aimView = AimTargetViewUpdater::Create(allocator, resAimView);
413         cameraView = aimView;
414     }
415     else if (viewType == ResCamera::VIEWTYPE_LOOKAT)
416     {
417         ResLookAtTargetViewUpdater resLookAtView(resViewUpdater.ptr());
418         LookAtTargetViewUpdater* lookAtView
419             = LookAtTargetViewUpdater::Create(allocator, resLookAtView);
420 
421         cameraView = lookAtView;
422     }
423     else if (viewType == ResCamera::VIEWTYPE_ROTATE)
424     {
425         ResRotateViewUpdater resRotateView(resViewUpdater.ptr());
426         RotateViewUpdater* rotateView = RotateViewUpdater::Create(allocator, resRotateView);
427 
428         cameraView = rotateView;
429     }
430     GfxPtr<CameraViewUpdater> viewUpdater(cameraView);
431 
432     // リソースからプロジェクションアップデータを作成します。
433     ResCamera::ProjType projType = resCamera.GetProjectionType();
434     ResCameraProjectionUpdater resProjectionUpdater = resCamera.GetProjectionUpdater();
435     NW_ASSERT(resProjectionUpdater.IsValid());
436     NW_ASSERT(projType < ResCamera::PROJTYPE_COUNT);
437     CameraProjectionUpdater* cameraProjection = NULL;
438     if (projType == ResCamera::PROJTYPE_PERSPECTIVE)
439     {
440         ResPerspectiveProjectionUpdater resPersProjection(resProjectionUpdater.ptr());
441         PerspectiveProjectionUpdater* persProjection =
442             PerspectiveProjectionUpdater::Create(allocator, resPersProjection);
443 
444         cameraProjection = persProjection;
445     }
446     else if (projType == ResCamera::PROJTYPE_FRUSTUM)
447     {
448         ResFrustumProjectionUpdater resFrustumProjection(resProjectionUpdater.ptr());
449         FrustumProjectionUpdater* frustumProjection = FrustumProjectionUpdater::Create(allocator, resFrustumProjection);
450 
451         cameraProjection = frustumProjection;
452     }
453     else if (projType == ResCamera::PROJTYPE_ORTHO)
454     {
455         ResOrthoProjectionUpdater resOrthoProjection(resProjectionUpdater.ptr());
456         OrthoProjectionUpdater* orthoProjection = OrthoProjectionUpdater::Create(allocator, resOrthoProjection);
457 
458         cameraProjection = orthoProjection;
459     }
460     GfxPtr<CameraProjectionUpdater> projectionUpdater(cameraProjection);
461 
462     Camera* camera = new(memory) Camera(
463         allocator,
464         resCamera,
465         description,
466         viewUpdater,
467         projectionUpdater,
468         resCamera.GetWScale(),
469         false);
470 
471     camera->Initialize(allocator);
472 
473     if (parent)
474     {
475         bool result = parent->AttachChild(camera);
476         NW_ASSERT(result);
477     }
478 
479     return camera;
480 }
481 
482 //----------------------------------------------------------
483 void
GetMemorySizeInternal(os::MemorySizeCalculator * pSize,ResCamera resCamera,Description description)484 Camera::GetMemorySizeInternal(
485     os::MemorySizeCalculator* pSize,
486     ResCamera resCamera,
487     Description description
488 )
489 {
490     NW_ASSERT(description.isFixedSizeMemory);
491 
492     os::MemorySizeCalculator& size = *pSize;
493 
494     // Camera::Create
495     size += sizeof(Camera);
496 
497     ResCamera::ViewType viewType = resCamera.GetViewType();
498     NW_ASSERT(viewType < ResCamera::VIEWTYPE_COUNT);
499     if (viewType == ResCamera::VIEWTYPE_AIM)
500     {
501         AimTargetViewUpdater::GetMemorySizeInternal(&size, false);
502     }
503     else if (viewType == ResCamera::VIEWTYPE_LOOKAT)
504     {
505         LookAtTargetViewUpdater::GetMemorySizeInternal(&size, false);
506     }
507     else if (viewType == ResCamera::VIEWTYPE_ROTATE)
508     {
509         RotateViewUpdater::GetMemorySizeInternal(&size, false);
510     }
511 
512     ResCamera::ProjType projType = resCamera.GetProjectionType();
513     NW_ASSERT(projType < ResCamera::PROJTYPE_COUNT);
514     if (projType == ResCamera::PROJTYPE_PERSPECTIVE)
515     {
516         PerspectiveProjectionUpdater::GetMemorySizeInternal(&size, false);
517     }
518     else if (projType == ResCamera::PROJTYPE_FRUSTUM)
519     {
520         FrustumProjectionUpdater::GetMemorySizeInternal(&size, false);
521     }
522     else if (projType == ResCamera::PROJTYPE_ORTHO)
523     {
524         OrthoProjectionUpdater::GetMemorySizeInternal(&size, false);
525     }
526 
527     // Camera::Initialize
528     TransformNode::GetMemorySizeForInitialize(&size, resCamera, description);
529 
530     // Camera::StoreOriginal
531     size += sizeof(ResCameraData);
532 
533     switch (viewType)
534     {
535     case ResCamera::VIEWTYPE_AIM:
536         size += sizeof(ResAimTargetViewUpdaterData);
537         break;
538     case ResCamera::VIEWTYPE_LOOKAT:
539         size += sizeof(ResLookAtTargetViewUpdaterData);
540         break;
541     case ResCamera::VIEWTYPE_ROTATE:
542         size += sizeof(ResRotateViewUpdaterData);
543         break;
544     default:
545         NW_ASSERT(false);
546     }
547 
548     switch (projType)
549     {
550     case ResCamera::PROJTYPE_PERSPECTIVE:
551         size += sizeof(ResPerspectiveProjectionUpdaterData);
552         break;
553     case ResCamera::PROJTYPE_FRUSTUM:
554         size += sizeof(ResFrustumProjectionUpdaterData);
555         break;
556     case ResCamera::PROJTYPE_ORTHO:
557         size += sizeof(ResOrthoProjectionUpdaterData);
558         break;
559     default:
560         NW_ASSERT(false);
561     }
562 
563     // Camera::CreateAnimGroup
564     if (description.isAnimationEnabled &&
565         resCamera.GetAnimGroupsCount() > 0)
566     {
567         AnimGroup::Builder()
568             .ResAnimGroup(resCamera.GetAnimGroups(0))
569             .UseOriginalValue(true)
570             .GetMemorySizeInternal(&size);
571     }
572 }
573 
574 //----------------------------------------
575 void
Accept(ISceneVisitor * visitor)576 Camera::Accept(
577     ISceneVisitor* visitor
578 )
579 {
580     visitor->VisitCamera(this);
581     AcceptChildren(visitor);
582 }
583 
584 //----------------------------------------
585 void
UpdateCameraMatrix()586 Camera::UpdateCameraMatrix()
587 {
588     NW_NULL_ASSERT(this->m_ViewUpdater);
589     NW_NULL_ASSERT(this->m_ProjectionUpdater);
590 
591     SceneNode* parentNode = this->GetParent();
592 
593     math::VEC3 cameraPosition(this->WorldMatrix().GetColumn(3));
594 
595     if (parentNode != NULL)
596     {
597         this->m_ViewUpdater->Update(&this->m_ViewMatrix, parentNode->TrackbackWorldMatrix(), cameraPosition);
598     }
599     else
600     {
601         this->m_ViewUpdater->Update(&this->m_ViewMatrix, math::MTX34::Identity(), cameraPosition);
602     }
603 
604     NW_FAILSAFE_IF(math::MTX34Inverse(&this->m_InverseViewMatrix, &this->m_ViewMatrix) == 0)
605     {
606         this->m_InverseViewMatrix = math::MTX34::Identity();
607     }
608 
609     this->m_ProjectionUpdater->Update(&this->m_ProjectionMatrix, &this->m_TextureProjectionMatrix);
610 
611     NW_FAILSAFE_IF(math::MTX44Inverse(&this->m_InverseProjectionMatrix, &this->m_ProjectionMatrix) == 0)
612     {
613         this->m_InverseProjectionMatrix = math::MTX34::Identity();
614     }
615 }
616 
617 
618 
619 //----------------------------------------
620 const nw::math::VEC3&
GetTargetPosition() const621 Camera::GetTargetPosition() const
622 {
623     const ResAimTargetViewUpdater resAim =
624         ResDynamicCast<const ResAimTargetViewUpdater>( GetViewUpdater()->GetResource() );
625     const ResLookAtTargetViewUpdater resLookAt =
626         ResDynamicCast<const ResLookAtTargetViewUpdater>( GetViewUpdater()->GetResource() );
627 
628     if (resAim.IsValid())
629     {
630         return resAim.GetTargetPosition();
631     }
632     else if (resLookAt.IsValid())
633     {
634         return resLookAt.GetTargetPosition();
635     }
636     else
637     {
638         NW_ASSERTMSG(false, "View updater isn't \"Aim\" nor \"LookAt\"");
639         return resAim.GetTargetPosition();
640     }
641 }
642 
643 //----------------------------------------
644 void
SetTargetPosition(const nw::math::VEC3 & targetPosition)645 Camera::SetTargetPosition(const nw::math::VEC3& targetPosition)
646 {
647     ResAimTargetViewUpdater resAim =
648         ResDynamicCast<ResAimTargetViewUpdater>( GetViewUpdater()->GetResource() );
649     ResLookAtTargetViewUpdater resLookAt =
650         ResDynamicCast<ResLookAtTargetViewUpdater>( GetViewUpdater()->GetResource() );
651 
652     if (resAim.IsValid())
653     {
654         resAim.SetTargetPosition(targetPosition);
655     }
656     else if (resLookAt.IsValid())
657     {
658         resLookAt.SetTargetPosition(targetPosition);
659     }
660     else
661     {
662         NW_ASSERTMSG(false, "View updater isn't \"Aim\" nor \"LookAt\"");
663     }
664 }
665 
666 //----------------------------------------
667 const nw::math::VEC3&
GetUpwardVector() const668 Camera::GetUpwardVector() const
669 {
670     const ResLookAtTargetViewUpdater resLookAt =
671         ResDynamicCast<const ResLookAtTargetViewUpdater>( GetViewUpdater()->GetResource() );
672 
673     NW_ASSERTMSG(resLookAt.IsValid(), "View updater isn't \"LookAt\"");
674 
675     return resLookAt.GetUpwardVector();
676 }
677 
678 //----------------------------------------
679 void
SetUpwardVector(const nw::math::VEC3 & upwardVector)680 Camera::SetUpwardVector(const nw::math::VEC3& upwardVector)
681 {
682     ResLookAtTargetViewUpdater resLookAt =
683         ResDynamicCast<ResLookAtTargetViewUpdater>( GetViewUpdater()->GetResource() );
684 
685     NW_ASSERTMSG(resLookAt.IsValid(), "View updater isn't \"LookAt\"");
686 
687     resLookAt.SetUpwardVector(upwardVector);
688 }
689 
690 //----------------------------------------
691 f32
GetTwist() const692 Camera::GetTwist() const
693 {
694     ResAimTargetViewUpdater resAim =
695         ResDynamicCast<ResAimTargetViewUpdater>( GetViewUpdater()->GetResource() );
696 
697     NW_ASSERTMSG(resAim.IsValid(), "View updater isn't \"LookAt\"");
698 
699     return resAim.GetTwist();
700 }
701 
702 //----------------------------------------
703 void
SetTwist(f32 twist)704 Camera::SetTwist(f32 twist)
705 {
706     ResAimTargetViewUpdater resAim =
707         ResDynamicCast<ResAimTargetViewUpdater>( GetViewUpdater()->GetResource() );
708 
709     NW_ASSERTMSG(resAim.IsValid(), "View updater isn't \"LookAt\"");
710 
711     resAim.SetTwist(twist);
712 }
713 
714 //----------------------------------------
715 const nw::math::VEC3&
GetViewRotate() const716 Camera::GetViewRotate() const
717 {
718     const ResRotateViewUpdater resRotate =
719         ResDynamicCast<const ResRotateViewUpdater>( GetViewUpdater()->GetResource() );
720 
721     NW_ASSERTMSG(resRotate.IsValid(), "View updater isn't \"Rotate\"");
722 
723     return resRotate.GetViewRotate();
724 }
725 
726 //----------------------------------------
727 void
SetViewRotate(const nw::math::VEC3 & viewRotate)728 Camera::SetViewRotate(const nw::math::VEC3& viewRotate)
729 {
730     ResRotateViewUpdater resRotate =
731         ResDynamicCast<ResRotateViewUpdater>( GetViewUpdater()->GetResource() );
732 
733     NW_ASSERTMSG(resRotate.IsValid(), "View updater isn't \"Rotate\"");
734 
735     resRotate.SetViewRotate(viewRotate);
736 }
737 
738 
739 
740 
741 //----------------------------------------
742 void
GetPerspective(f32 * fovy,f32 * aspectRatio,f32 * nearClip,f32 * farClip) const743 Camera::GetPerspective(
744     f32* fovy,
745     f32* aspectRatio,
746     f32* nearClip,
747     f32* farClip
748 ) const
749 {
750     const ResPerspectiveProjectionUpdater resource =
751         ResDynamicCast<const ResPerspectiveProjectionUpdater>( GetProjectionUpdater()->GetResource() );
752 
753     NW_ASSERTMSG(resource.IsValid(), "Projection updater isn't perspective");
754 
755     if (fovy)
756     {
757         *fovy = resource.GetFovy();
758     }
759     if (aspectRatio)
760     {
761         *aspectRatio = resource.GetAspectRatio();
762     }
763     if (nearClip)
764     {
765         *nearClip = resource.GetNear();
766     }
767     if (farClip)
768     {
769         *farClip = resource.GetFar();
770     }
771 }
772 
773 //----------------------------------------
774 void
SetPerspective(f32 fovy,f32 aspectRatio,f32 nearClip,f32 farClip)775 Camera::SetPerspective(
776     f32 fovy,
777     f32 aspectRatio,
778     f32 nearClip,
779     f32 farClip
780 )
781 {
782     ResPerspectiveProjectionUpdater resource =
783         ResDynamicCast<ResPerspectiveProjectionUpdater>( GetProjectionUpdater()->GetResource() );
784 
785     NW_ASSERTMSG(resource.IsValid(), "Projection updater isn't perspective");
786 
787     resource.SetFovy(fovy);
788     resource.SetAspectRatio(aspectRatio);
789     resource.SetNear(nearClip);
790     resource.SetFar(farClip);
791 }
792 
793 //----------------------------------------
794 void
GetFrustum(f32 * left,f32 * right,f32 * bottom,f32 * top,f32 * nearClip,f32 * farClip) const795 Camera::GetFrustum(
796     f32* left,
797     f32* right,
798     f32* bottom,
799     f32* top,
800     f32* nearClip,
801     f32* farClip
802 ) const
803 {
804     const ResFrustumProjectionUpdater resource =
805         ResDynamicCast<const ResFrustumProjectionUpdater>( GetProjectionUpdater()->GetResource() );
806 
807     NW_ASSERTMSG(resource.IsValid(), "Projection updater isn't frustum");
808 
809     if (left && right && bottom && top)
810     {
811         const ut::Rect rect = resource.GetRect();
812         if (left)
813         {
814             *left = rect.left;
815         }
816         if (right)
817         {
818             *right = rect.right;
819         }
820         if (bottom)
821         {
822             *bottom = rect.bottom;
823         }
824         if (top)
825         {
826             *top = rect.top;
827         }
828     }
829     if (nearClip)
830     {
831         *nearClip = resource.GetNear();
832     }
833     if (farClip)
834     {
835         *farClip = resource.GetFar();
836     }
837 }
838 
839 //----------------------------------------
840 void
SetFrustum(f32 left,f32 right,f32 bottom,f32 top,f32 nearClip,f32 farClip)841 Camera::SetFrustum(
842     f32 left,
843     f32 right,
844     f32 bottom,
845     f32 top,
846     f32 nearClip,
847     f32 farClip
848 )
849 {
850     ResFrustumProjectionUpdater resource =
851         ResDynamicCast<ResFrustumProjectionUpdater>( GetProjectionUpdater()->GetResource() );
852 
853     NW_ASSERTMSG(resource.IsValid(), "Projection updater isn't frustum");
854 
855     resource.SetRectWithoutFlip(left, right, bottom, top);
856     resource.SetNear(nearClip);
857     resource.SetFar(farClip);
858 }
859 
860 //----------------------------------------
861 void
GetOrtho(f32 * left,f32 * right,f32 * bottom,f32 * top,f32 * nearClip,f32 * farClip) const862 Camera::GetOrtho(
863     f32* left,
864     f32* right,
865     f32* bottom,
866     f32* top,
867     f32* nearClip,
868     f32* farClip
869 ) const
870 {
871     const ResOrthoProjectionUpdater resource =
872         ResDynamicCast<const ResOrthoProjectionUpdater>( GetProjectionUpdater()->GetResource() );
873 
874     NW_ASSERTMSG(resource.IsValid(), "Projection updater isn't ortho");
875 
876     if (left && right && bottom && top)
877     {
878         const ut::Rect rect = resource.GetRect();
879         if (left)
880         {
881             *left = rect.left;
882         }
883         if (right)
884         {
885             *right = rect.right;
886         }
887         if (bottom)
888         {
889             *bottom = rect.bottom;
890         }
891         if (top)
892         {
893             *top = rect.top;
894         }
895     }
896     if (nearClip)
897     {
898         *nearClip = resource.GetNear();
899     }
900     if (farClip)
901     {
902         *farClip = resource.GetFar();
903     }
904 }
905 
906 //----------------------------------------
907 void
SetOrtho(f32 left,f32 right,f32 bottom,f32 top,f32 nearClip,f32 farClip)908 Camera::SetOrtho(
909     f32 left,
910     f32 right,
911     f32 bottom,
912     f32 top,
913     f32 nearClip,
914     f32 farClip
915 )
916 {
917     ResOrthoProjectionUpdater resource =
918         ResDynamicCast<ResOrthoProjectionUpdater>( GetProjectionUpdater()->GetResource() );
919 
920     NW_ASSERTMSG(resource.IsValid(), "Projection updater isn't ortho");
921 
922     resource.SetRectWithoutFlip(left, right, bottom, top);
923     resource.SetNear(nearClip);
924     resource.SetFar(farClip);
925 }
926 
927 //----------------------------------------
928 void
GetFrustum(ut::Rect * rect,f32 * nearClip,f32 * farClip) const929 Camera::GetFrustum(
930     ut::Rect* rect,
931     f32* nearClip,
932     f32* farClip
933 ) const
934 {
935     const ResFrustumProjectionUpdater resource =
936         ResDynamicCast<const ResFrustumProjectionUpdater>( GetProjectionUpdater()->GetResource() );
937 
938     NW_ASSERTMSG(resource.IsValid(), "Projection updater isn't frustum");
939 
940     if (rect)
941     {
942         *rect = resource.GetRect();
943     }
944     if (nearClip)
945     {
946         *nearClip = resource.GetNear();
947     }
948     if (farClip)
949     {
950         *farClip = resource.GetFar();
951     }
952 }
953 
954 //----------------------------------------
955 void
SetFrustum(const ut::Rect & rect,f32 nearClip,f32 farClip)956 Camera::SetFrustum(
957     const ut::Rect& rect,
958     f32 nearClip,
959     f32 farClip
960 )
961 {
962     SetFrustum(rect.left, rect.right, rect.bottom, rect.top, nearClip, farClip);
963 }
964 
965 //----------------------------------------
966 void
GetOrtho(ut::Rect * rect,f32 * nearClip,f32 * farClip) const967 Camera::GetOrtho(
968     ut::Rect* rect,
969     f32* nearClip,
970     f32* farClip
971 ) const
972 {
973     const ResOrthoProjectionUpdater resource =
974         ResDynamicCast<const ResOrthoProjectionUpdater>( GetProjectionUpdater()->GetResource() );
975 
976     NW_ASSERTMSG(resource.IsValid(), "Projection updater isn't ortho");
977 
978     if (rect)
979     {
980         *rect = resource.GetRect();
981     }
982     if (nearClip)
983     {
984         *nearClip = resource.GetNear();
985     }
986     if (farClip)
987     {
988         *farClip = resource.GetFar();
989     }
990 }
991 
992 //----------------------------------------
993 void
SetOrtho(const ut::Rect & rect,f32 nearClip,f32 farClip)994 Camera::SetOrtho(
995     const ut::Rect& rect,
996     f32 nearClip,
997     f32 farClip
998 )
999 {
1000     SetOrtho(rect.left, rect.right, rect.bottom, rect.top, nearClip, farClip);
1001 }
1002 
1003 //----------------------------------------
1004 void
SetFrustum(const Viewport & viewport)1005 Camera::SetFrustum(
1006     const Viewport& viewport
1007 )
1008 {
1009     SetFrustum(viewport.GetBound(), viewport.GetDepthNear(), viewport.GetDepthFar());
1010 }
1011 
1012 //----------------------------------------
1013 void
SetOrtho(const Viewport & viewport)1014 Camera::SetOrtho(
1015     const Viewport& viewport
1016 )
1017 {
1018     SetOrtho(viewport.GetBound(), viewport.GetDepthNear(), viewport.GetDepthFar());
1019 }
1020 
1021 //-----------------------------------------
1022 f32
GetNear() const1023 Camera::GetNear() const
1024 {
1025     const ResCameraProjectionUpdater resource =
1026         ResDynamicCast<const ResCameraProjectionUpdater>( GetProjectionUpdater()->GetResource() );
1027 
1028     NW_ASSERT(resource.IsValid());
1029 
1030     return resource.GetNear();
1031 }
1032 
1033 //-----------------------------------------
1034 void
SetNear(f32 near)1035 Camera::SetNear(f32 near)
1036 {
1037     ResCameraProjectionUpdater resource =
1038         ResDynamicCast<ResCameraProjectionUpdater>( GetProjectionUpdater()->GetResource() );
1039 
1040     NW_ASSERT(resource.IsValid());
1041 
1042     resource.SetNear(near);
1043 }
1044 
1045 //-----------------------------------------
1046 f32
GetFar() const1047 Camera::GetFar() const
1048 {
1049     const ResCameraProjectionUpdater resource =
1050         ResDynamicCast<const ResCameraProjectionUpdater>( GetProjectionUpdater()->GetResource() );
1051 
1052     NW_ASSERT(resource.IsValid());
1053 
1054     return resource.GetFar();
1055 }
1056 
1057 //-----------------------------------------
1058 void
SetFar(f32 far)1059 Camera::SetFar(f32 far)
1060 {
1061     ResCameraProjectionUpdater resource =
1062         ResDynamicCast<ResCameraProjectionUpdater>( GetProjectionUpdater()->GetResource() );
1063 
1064     NW_ASSERT(resource.IsValid());
1065 
1066     resource.SetFar(far);
1067 }
1068 
1069 //----------------------------------------
1070 Result
StoreOriginal(os::IAllocator * allocator)1071 Camera::StoreOriginal(os::IAllocator* allocator)
1072 {
1073     Result result = INITIALIZE_RESULT_OK;
1074 
1075     ResCamera original = this->GetResCamera();
1076     NW_NULL_ASSERT(original.GetViewUpdater().ptr());
1077     NW_NULL_ASSERT(original.GetProjectionUpdater().ptr());
1078 
1079     void* cameraMemory = allocator->Alloc(sizeof(ResCameraData));
1080     NW_NULL_ASSERT(cameraMemory);
1081 
1082     ResCameraData* cameraData =
1083         new(cameraMemory) ResCameraData(original.ref());
1084 
1085     cameraData->toViewUpdater = NULL;
1086     cameraData->toProjectionUpdater = NULL;
1087 
1088     // viewUpdaterのコピー
1089     void* viewUpdaterMemory = NULL;
1090     ResCameraViewUpdaterData* viewUpdaterData = NULL;
1091     switch (original.GetViewType())
1092     {
1093     case ResCamera::VIEWTYPE_AIM:
1094         viewUpdaterMemory = allocator->Alloc(sizeof(ResAimTargetViewUpdaterData));
1095         NW_NULL_ASSERT(viewUpdaterMemory);
1096         viewUpdaterData =
1097             new(viewUpdaterMemory) ResAimTargetViewUpdaterData(
1098                 *reinterpret_cast<ResAimTargetViewUpdaterData*>(original.GetViewUpdater().ptr()));
1099         break;
1100 
1101     case ResCamera::VIEWTYPE_LOOKAT:
1102         viewUpdaterMemory = allocator->Alloc(sizeof(ResLookAtTargetViewUpdaterData));
1103         NW_NULL_ASSERT(viewUpdaterMemory);
1104         viewUpdaterData =
1105             new(viewUpdaterMemory) ResLookAtTargetViewUpdaterData(
1106                 *reinterpret_cast<ResLookAtTargetViewUpdaterData*>(original.GetViewUpdater().ptr()));
1107         break;
1108 
1109     case ResCamera::VIEWTYPE_ROTATE:
1110         viewUpdaterMemory = allocator->Alloc(sizeof(ResRotateViewUpdaterData));
1111         NW_NULL_ASSERT(viewUpdaterMemory);
1112         viewUpdaterData =
1113             new(viewUpdaterMemory) ResRotateViewUpdaterData(
1114                 *reinterpret_cast<ResRotateViewUpdaterData*>(original.GetViewUpdater().ptr()));
1115         break;
1116 
1117     default:
1118         NW_ASSERT(false);
1119     }
1120 
1121     cameraData->toViewUpdater.set_ptr(viewUpdaterData);
1122 
1123     // ProjectionUpdaterのコピー
1124     void* projectionUpdaterMemory = NULL;
1125     ResCameraProjectionUpdaterData* projectionUpdaterData = NULL;
1126 
1127     switch (original.GetProjectionType())
1128     {
1129     case ResCamera::PROJTYPE_PERSPECTIVE:
1130         projectionUpdaterMemory = allocator->Alloc(sizeof(ResPerspectiveProjectionUpdaterData));
1131         NW_NULL_ASSERT(projectionUpdaterMemory);
1132         projectionUpdaterData =
1133             new(projectionUpdaterMemory) ResPerspectiveProjectionUpdaterData(
1134                 *reinterpret_cast<ResPerspectiveProjectionUpdaterData*>(original.GetProjectionUpdater().ptr()));
1135         break;
1136 
1137     case ResCamera::PROJTYPE_FRUSTUM:
1138         projectionUpdaterMemory = allocator->Alloc(sizeof(ResFrustumProjectionUpdaterData));
1139         NW_NULL_ASSERT(projectionUpdaterMemory);
1140         projectionUpdaterData =
1141             new(projectionUpdaterMemory) ResFrustumProjectionUpdaterData(
1142                 *reinterpret_cast<ResFrustumProjectionUpdaterData*>(original.GetProjectionUpdater().ptr()));
1143         break;
1144 
1145     case ResCamera::PROJTYPE_ORTHO:
1146         projectionUpdaterMemory = allocator->Alloc(sizeof(ResOrthoProjectionUpdaterData));
1147         NW_NULL_ASSERT(projectionUpdaterMemory);
1148         projectionUpdaterData =
1149             new(projectionUpdaterMemory) ResOrthoProjectionUpdaterData(
1150                 *reinterpret_cast<ResOrthoProjectionUpdaterData*>(original.GetProjectionUpdater().ptr()));
1151         break;
1152 
1153     default:
1154         NW_ASSERT(false);
1155     }
1156 
1157     cameraData->toProjectionUpdater.set_ptr(projectionUpdaterData);
1158 
1159     // メンバに保存
1160     m_OriginalValue = ResCamera(cameraData);
1161 
1162     // CalculatedTransformを保存
1163     m_OriginalTransform = this->GetResTransformNode().GetTransform();
1164 
1165     return result;
1166 }
1167 
1168 //-----------------------------------------
1169 void
DestroyResCamera(os::IAllocator * allocator,ResCamera resCamera)1170 Camera::DestroyResCamera(os::IAllocator* allocator, ResCamera resCamera)
1171 {
1172     NW_NULL_ASSERT( allocator );
1173     if (resCamera.IsValid())
1174     {
1175         if (resCamera.GetProjectionUpdater().IsValid())
1176         {
1177             allocator->Free(resCamera.GetProjectionUpdater().ptr());
1178             resCamera.ref().toProjectionUpdater.set_ptr(NULL);
1179         }
1180         if (resCamera.GetViewUpdater().IsValid())
1181         {
1182             allocator->Free(resCamera.GetViewUpdater().ptr());
1183             resCamera.ref().toViewUpdater.set_ptr(NULL);
1184         }
1185 
1186         allocator->Free(resCamera.ptr());
1187     }
1188 }
1189 
1190 //-----------------------------------------
1191 void*
GetAnimTargetObject(const anim::ResAnimGroupMember & anim)1192 Camera::GetAnimTargetObject(const anim::ResAnimGroupMember& anim)
1193 {
1194     switch(anim.GetObjectType())
1195     {
1196     case anim::ResAnimGroupMember::OBJECT_TYPE_TRANSFORM:
1197         {
1198             return static_cast<gfx::TransformNode*>(this);
1199         }
1200 
1201     case anim::ResAnimGroupMember::OBJECT_TYPE_VIEW_UPDATER:
1202         {
1203             ResCameraViewUpdaterData* ptr = GetViewUpdater()->GetResource().ptr();
1204             return ptr;
1205         }
1206 
1207     case anim::ResAnimGroupMember::OBJECT_TYPE_PROJECTION_UPDATER:
1208         {
1209             ResCameraProjectionUpdaterData* ptr = GetProjectionUpdater()->GetResource().ptr();
1210             return ptr;
1211         }
1212 
1213     default:
1214         NW_ASSERT(false);
1215         return NULL;
1216     }
1217 }
1218 
1219 //----------------------------------------
1220 Result
Initialize(os::IAllocator * allocator)1221 Camera::Initialize(os::IAllocator* allocator)
1222 {
1223     Result result = INITIALIZE_RESULT_OK;
1224 
1225     result |= TransformNode::Initialize(allocator);
1226     NW_ENSURE_AND_RETURN(result);
1227 
1228     result |= StoreOriginal(allocator);
1229     result |= CreateAnimGroup(allocator);
1230 
1231     return result;
1232 }
1233 
1234 //----------------------------------------
1235 bool
ValidateCameraAnimType(AnimObject * animObject)1236 Camera::ValidateCameraAnimType(AnimObject* animObject)
1237 {
1238     if (animObject == NULL)
1239     {
1240         // NULLの時はアニメを取り外そうとしているので、型チェックは通る
1241         return true;
1242     }
1243 
1244     // blenderならば、再帰的に調べないといけない
1245     AnimBlender* blender = ut::DynamicCast<AnimBlender*>(animObject);
1246 
1247     if (blender != NULL)
1248     {
1249         const int animObjCount = blender->GetAnimObjectCount();
1250         for (int i = 0; i < animObjCount; ++i)
1251         {
1252             AnimObject* animObj = blender->GetAnimObject(i);
1253 
1254             // ひとつでもvalidateに失敗したらfalseを返す
1255             if (!ValidateCameraAnimType(animObj))
1256             {
1257                 return false;
1258             }
1259         }
1260 
1261         // 全てのAnimObjectのチェックを通過すれば成功
1262         return true;
1263     }
1264     else
1265     {
1266         // blenderではなかったので、AnimEvaluatorのはず
1267         AnimEvaluator* evaluator = ut::DynamicCast<AnimEvaluator*>(animObject);
1268         NW_NULL_ASSERT(evaluator);
1269 
1270         anim::ResCameraAnim cameraAnim(evaluator->GetAnimData().ptr());
1271 
1272         return (
1273             (cameraAnim.GetProjectionUpdaterKind() == m_ProjectionUpdater->Kind()) &&
1274             (cameraAnim.GetViewUpdaterKind() == m_ViewUpdater->Kind()));
1275     }
1276 }
1277 
1278 } // namespace gfx
1279 } // namespace nw
1280