Benoit Bolsee
149d231d69
The new class VideoTexture.ImageMirror() is available to perform
automatic mirror rendering.
Constructor:
VideoTexture.ImageMirror(scene,observer,mirror,material)
scene: reference to the scene that will be rendered.
Both observer and mirror must be part of that scene.
observer: reference to a game object used as view point for
mirror rendering: the scene will be rendered through
the mirror as if the active camera was at the observer
location. Usually the observer is the active camera
but you can use any game obejct.
mirror: reference to the mesh object holding the mirror.
material: material ID of the mirror texture as returned by
VideoTexture.materialID(). The mirror is formed by
the polygons mapped to that material.
There are no specific methods or attributes. ImageMirror inherits
all methods and attributes from ImageRender. You must refresh the
parent VideoTexture.Texture object regularly to update the mirror
rendering.
Guidelines on how to create a working mirror:
- Use a texture that is specific to the mirror so that the mirror
rendering only appears on the mirror.
- The mirror must be planar; the algorithm works well only for planar
or quasi planar mirror. For spherical mirror, you will get better
results with ImageRender and a camera at the center of the mirror.
ImageMirror automatically computes the mirror orientation and
position. The mirror doesn't need to be rectangular, it can be
circular or take any form provided it is planar.
- The mirror up direction must be along the Z axis in local mesh
coordinates. If the mirror is not vertical, ImageMirror will
compute the up direction as being the projection of the Z axis
on the mirror plane.
- UV mapping must be set right to get correct mirror rendering:
- make a planar projection of the mirror polygons (Unwrap or projection from view)
- eventually rotate the projection so that UV up direction corresponds to the mesh Z axis
- scale the projection so that the extreme points touch the border of the texture
- flip the UV projection horizontally (scale -1 on X axis). This is needed
because the mirror texture is rendered from the back of the mirror and
thus is reversed from the view point of the observer. Horizontal flip
in the UV map restores the correct orientation.
Besides these simple rules, the mirror rendering is completely automatic.
In particular, you don't need to allocate a camera for the rendering,
ImageMirror creates dynamically a camera for that. The reflection is correct
even on large angles. The mirror can be a dynamic and moving object, the
algorithm always computes the correct camera position based on observer
relative position. You don't have to worry about mirror position in the scene:
the algorithm automatically computes the camera frustum so that any object
behind the mirror is not rendered.
Warnings:
- observer and mirror are references to game objects. ImageMirror keeps
a pointer to them but does not increment the reference count. You must ensure
that these game objects are not deleted as long as you refresh() the ImageMirror
object. You must release the ImageMirror object before you delete the game
objects. To release the ImageMirror object (normally stored in GameLogic),
just assign it to None.
- Mirror rendering is automatically skipped when the observer is behind the mirror
but it is not disabled when the mirror is out of sight of the observer.
You should only refresh the mirror when you know that the observer is likely to see it.
For example, no need to refresh a car inner mirror when the player is not in the car.
Example:
contr = GameLogic.getCurrentController()
# object holding the mirror
mirror = contr.getOwner()
scene = GameLogic.getCurrentScene()
# observer will be the active camere
camera = scene.getObjectList()['OBCamera']
matID = VideoTexture.materialID(mirror, 'IMmirror.png')
GameLogic.mirror = VideoTexture.Texture(mirror, matID)
GameLogic.mirror.source = VideoTexture.ImageMirror(scene,camera,mirror,matID)
# to render the mirror, just call GameLogic.mirror.refresh(True) on each frame.
You can download a demo game (with a video file) here:
http://home.scarlet.be/~tsi46445/blender/VideoTextureDemo.zip
For those who have already downloaded the demo, you can just update the blend file:
http://home.scarlet.be/~tsi46445/blender/MirrorTextureDemo.blend
99 lines
3.0 KiB
C++
99 lines
3.0 KiB
C++
/* $Id$
|
|
-----------------------------------------------------------------------------
|
|
This source file is part of VideoTexture library
|
|
|
|
Copyright (c) 2007 The Zdeno Ash Miklas
|
|
|
|
This program is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU Lesser General Public License as published by the Free Software
|
|
Foundation; either version 2 of the License, or (at your option) any later
|
|
version.
|
|
|
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License along with
|
|
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
|
|
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
|
|
http://www.gnu.org/copyleft/lesser.txt.
|
|
-----------------------------------------------------------------------------
|
|
*/
|
|
|
|
#if !defined IMAGERENDER_H
|
|
#define IMAGERENDER_H
|
|
|
|
|
|
#include "Common.h"
|
|
|
|
#include <KX_Scene.h>
|
|
#include <KX_Camera.h>
|
|
#include <DNA_screen_types.h>
|
|
#include <RAS_ICanvas.h>
|
|
#include <RAS_IRasterizer.h>
|
|
#include <RAS_IRenderTools.h>
|
|
|
|
#include "ImageViewport.h"
|
|
|
|
|
|
/// class for render 3d scene
|
|
class ImageRender : public ImageViewport
|
|
{
|
|
public:
|
|
/// constructor
|
|
ImageRender (KX_Scene * scene, KX_Camera * camera);
|
|
ImageRender (KX_Scene * scene, KX_GameObject * observer, KX_GameObject * mirror, RAS_IPolyMaterial * mat);
|
|
|
|
/// destructor
|
|
virtual ~ImageRender (void);
|
|
|
|
/// get background color
|
|
int getBackground (int idx) { return (idx < 0 || idx > 3) ? 0 : int(m_background[idx]*255.f); }
|
|
/// set background color
|
|
void setBackground (int red, int green, int blue, int alpha);
|
|
|
|
protected:
|
|
/// true if ready to render
|
|
bool m_render;
|
|
/// rendered scene
|
|
KX_Scene * m_scene;
|
|
/// camera for render
|
|
KX_Camera * m_camera;
|
|
/// do we own the camera?
|
|
bool m_owncamera;
|
|
/// for mirror operation
|
|
KX_GameObject * m_observer;
|
|
KX_GameObject * m_mirror;
|
|
float m_mirrorHalfWidth; // mirror width in mirror space
|
|
float m_mirrorHalfHeight; // mirror height in mirror space
|
|
MT_Point3 m_mirrorPos; // mirror center position in local space
|
|
MT_Vector3 m_mirrorZ; // mirror Z axis in local space
|
|
MT_Vector3 m_mirrorY; // mirror Y axis in local space
|
|
MT_Vector3 m_mirrorX; // mirror X axis in local space
|
|
/// canvas
|
|
RAS_ICanvas* m_canvas;
|
|
/// rasterizer
|
|
RAS_IRasterizer* m_rasterizer;
|
|
/// render tools
|
|
RAS_IRenderTools* m_rendertools;
|
|
/// engine
|
|
KX_KetsjiEngine* m_engine;
|
|
|
|
/// background colour
|
|
float m_background[4];
|
|
|
|
|
|
/// render 3d scene to image
|
|
virtual void calcImage (unsigned int texId);
|
|
|
|
void Render();
|
|
void SetupRenderFrame(KX_Scene *scene, KX_Camera* cam);
|
|
void RenderFrame(KX_Scene* scene, KX_Camera* cam);
|
|
void SetBackGround(KX_WorldInfo* wi);
|
|
void SetWorldSettings(KX_WorldInfo* wi);
|
|
};
|
|
|
|
|
|
#endif
|
|
|