forked from bartvdbraak/blender
6a51ba54cd
The new class VideoTexture.ImageRender() is available to perform
render to texture in the GE.
Constructor:
VideoTexture.ImageRender(scene,cam)
cam : camera object that will be used for the render.
It must be an inactive camera.
scene: reference to the scene that will be rendered.
The camera must be part of that scene.
Returns an object that can be used as a source of a VideoTexture.Texture object
Methods: none
Attributes:
background:
4-tuple representing the background color of the rendering
as RGBA color components, each component being an integer
between 0 and 255.
Default value = [0,0,255,255] (=saturated blue)
Note: athough the alpha component can be specified, it is not
supported at the moment, the alpha channel of the rendered
texture will always be 255. You can however introduce an
alpha channel by appending a FilterBlueScreen() filter, it
will set the alpha to 0 (transparent) on all pixels that were
not rendered.
capsize:
2-tuple representing the size of the render area as [x,y] number of pixels.
Default value = largest rectangle with power of 2 dimensions that fits in the canvas
You may want to reduce the render area to increase performance. For example,
a render area of [256,128] is probably sufficient to implement a car inner mirror.
For best performance, use power of 2 dimensions and don't set any filter: this
allows direct transfer between the GPU frame buffer and texture memory
without going through the host.
alpha:
Boolean indicating if the render alpha channel should be copied to the texture.
Default value: False
Experimental, do not use.
whole:
Boolean indicating if the entire canvas should be used for the rendering.
Default value: False
Note: There is no reason to set this attribute to True: the rendering will
in any case be scaled down to the largest rectangle with power of 2
dimensions before transfering to the texture.
Attributes inherited from the ImageBase class:
image : image binary data, read-only
size : [x,y] size of the texture, read-only
scale : set to True for fast scale down in case the render area dimensions are not power of 2
flip : set to True for vertical flip.
filter: set a post-processing filter on the render.
Notes:
* Aspect Ratio
For consistent results in Blender and Blenderplayer, the same aspect ratio used
by Blender to draw the camera viewport (Scene(F10)->Format tab->Size X/Size Y)
is also used during the rendering. You can control the portion of the scene that
will be rendered by "looking through the camera": the zone inside the outer dotted
rectangle will be rendered to the texture.
In order to reproduce the scene without X/Y distortion, you must apply the texture
on an object or portion of object that has the same aspect ratio.
* Order of rendering
The rendereing is performed when you call the refresh() method of the parent
Texture object. This happens outside the normal frame rendering and will have no
effect on it.
However, if you want to use ImageViewport and ImageRender at the same time, be
sure to refresh the viewport texture before the render texture because the latter
will destroy the frame buffer that is used by the former to update the texture.
* Scene status
The meshes are not updated during the render to texture: the rendered texture
is one frame late to the rendered frame with regards to mesh deformation.
* Example:
cont = GameLogic.getCurrentController()
# object that receives the texture
obj = contr.getOwner()
scene = GameLogic.getCurrentScene()
# camera used for the render
tvcam = scene.getObjectList()['OBtvcam']
# assume obj has some faces UV assigned to tv.png
matID = VideoTexture.materialID(obj, 'IMtv.png')
GameLogic.tv = VideoTexture.Texture(obj, matID)
GameLogic.tv.source = VideoTexture.ImageRender(scene,tvcam)
GameLogic.tv.source.capsize = [256,256]
# to render the texture, just call GameLogic.tv.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/VideoTextureDemo.blend
99 lines
2.8 KiB
C++
99 lines
2.8 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 IMAGEVIEWPORT_H
|
|
#define IMAGEVIEWPORT_H
|
|
|
|
|
|
#include "Common.h"
|
|
|
|
#include "ImageBase.h"
|
|
|
|
|
|
/// class for viewport access
|
|
class ImageViewport : public ImageBase
|
|
{
|
|
public:
|
|
/// constructor
|
|
ImageViewport (void);
|
|
|
|
/// destructor
|
|
virtual ~ImageViewport (void);
|
|
|
|
/// is whole buffer used
|
|
bool getWhole (void) { return m_whole; }
|
|
/// set whole buffer use
|
|
void setWhole (bool whole);
|
|
|
|
/// is alpha channel used
|
|
bool getAlpha (void) { return m_alpha; }
|
|
/// set whole buffer use
|
|
void setAlpha (bool alpha) { m_alpha = alpha; }
|
|
|
|
/// get capture size in viewport
|
|
short * getCaptureSize (void) { return m_capSize; }
|
|
/// set capture size in viewport
|
|
void setCaptureSize (short * size = NULL);
|
|
|
|
/// get position in viewport
|
|
GLint * getPosition (void) { return m_position; }
|
|
/// set position in viewport
|
|
void setPosition (GLint * pos = NULL);
|
|
|
|
protected:
|
|
/// frame buffer rectangle
|
|
GLint m_viewport[4];
|
|
|
|
/// size of captured area
|
|
short m_capSize[2];
|
|
/// use whole viewport
|
|
bool m_whole;
|
|
/// use alpha channel
|
|
bool m_alpha;
|
|
|
|
/// position of capture rectangle in viewport
|
|
GLint m_position[2];
|
|
/// upper left point for capturing
|
|
GLint m_upLeft[2];
|
|
|
|
/// buffer to copy viewport
|
|
BYTE * m_viewportImage;
|
|
/// texture is initialized
|
|
bool m_texInit;
|
|
|
|
/// capture image from viewport
|
|
virtual void calcImage (unsigned int texId);
|
|
|
|
/// get viewport size
|
|
GLint * getViewportSize (void) { return m_viewport + 2; }
|
|
};
|
|
|
|
PyObject * ImageViewport_getCaptureSize (PyImage * self, void * closure);
|
|
int ImageViewport_setCaptureSize (PyImage * self, PyObject * value, void * closure);
|
|
PyObject * ImageViewport_getWhole (PyImage * self, void * closure);
|
|
int ImageViewport_setWhole (PyImage * self, PyObject * value, void * closure);
|
|
PyObject * ImageViewport_getAlpha (PyImage * self, void * closure);
|
|
int ImageViewport_setAlpha (PyImage * self, PyObject * value, void * closure);
|
|
|
|
#endif
|
|
|