-#ifndef __DALI_INTERNAL_SCENE_GRAPH_RENDER_INSTRUCTION_H__
-#define __DALI_INTERNAL_SCENE_GRAPH_RENDER_INSTRUCTION_H__
+#ifndef DALI_INTERNAL_SCENE_GRAPH_RENDER_INSTRUCTION_H
+#define DALI_INTERNAL_SCENE_GRAPH_RENDER_INSTRUCTION_H
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// INTERNAL INCLUDES
#include <dali/public-api/math/matrix.h>
#include <dali/public-api/math/viewport.h>
-#include <dali/internal/update/node-attachments/scene-graph-camera-attachment.h>
+#include <dali/internal/update/render-tasks/scene-graph-camera.h>
#include <dali/internal/render/common/render-list.h>
+#include <dali/internal/render/renderers/render-frame-buffer.h>
+#include <dali/internal/render/gl-resources/context.h>
namespace Dali
{
namespace SceneGraph
{
-class CameraAttachment;
/**
* A set of rendering instructions consisting of:
* render-lists are cleared but not released, while matrices and other settings reset in
* preparation for building a set of instructions for the renderer.
*
- * @param[in] cameraAttachment to use to get view and projection matrices.
+ * @param[in] camera to use to get view and projection matrices.
* @param[in] offscreenId A resource Id of an off-screen render target, or 0
* @param[in] viewport A pointer to a viewport, of NULL.
* @param[in] clearColor A pointer to a color to clear with, or NULL if no clear is required.
*/
- void Reset( CameraAttachment* cameraAttachment,
- unsigned int offscreenId,
+ void Reset( Camera* camera,
+ Render::FrameBuffer* frameBuffer,
const Viewport* viewport,
const Vector4* clearColor );
const Matrix* GetViewMatrix( BufferIndex index ) const
{
// inlined as this is called once per frame per render instruction
- return &mCameraAttachment->GetViewMatrix( index );
+ return &mCamera->GetViewMatrix( index );
}
/**
const Matrix* GetProjectionMatrix( BufferIndex index ) const
{
// inlined as this is called once per frame per render instruction
- return &mCameraAttachment->GetProjectionMatrix( index );
+ return &mCamera->GetFinalProjectionMatrix( index );
+ }
+ // for reflection effect
+ const Camera* GetCamera() const
+ {
+ return mCamera;
}
private:
// Undefined
RenderInstruction& operator=(const RenderInstruction& rhs);
-public: // Data, TODO hide these
+public: // Data
Render::RenderTracker* mRenderTracker; ///< Pointer to an optional tracker object (not owned)
Vector4 mClearColor; ///< Optional color to clear with
bool mIsViewportSet:1; ///< Flag to determine whether the viewport is set
bool mIsClearColorSet:1; ///< Flag to determine whether the clearColor is set
+ bool mIgnoreRenderToFbo:1; ///< Whether to ignore the render to FBO option (used to measure the performance above 60 fps)
+
+ Render::FrameBuffer* mFrameBuffer;
- unsigned int mOffscreenTextureId; ///< Optional offscreen target
+ Context* mContext; ///< The context holding the GL state of rendering
private: // Data
- CameraAttachment* mCameraAttachment; ///< camera that is used
+ Camera* mCamera; ///< camera that is used
RenderListContainer mRenderLists; ///< container of all render lists
RenderListContainer::SizeType mNextFreeRenderList; ///< index for the next free render list
} // namespace Dali
-#endif // __DALI_INTERNAL_SCENE_GRAPH_RENDER_INSTRUCTION_H__
+#endif // DALI_INTERNAL_SCENE_GRAPH_RENDER_INSTRUCTION_H