Yamyam: 1版をインポートしました

2018-06-28T19:45:07Z

1版をインポートしました

wiki>Ndelgrosso: /* Download the demo */ Link Broken.

2013-11-15T14:32:27Z

‎Download the demo: Link Broken.

新規ページ

{{Page/Header|2.5|Doc:2.5/Manual/Game Engine/Python API/Bullet physics|Doc:2.5/Manual/Game Engine/Features}}

=The VideoTexture module: bge.texture=
The <code>VideoTexture</code> module allows you to manipulate textures during the game. Several sources for texture are possible: video files, image files, video capture, memory buffer, camera render or a mix of that. The video and image files can be loaded from the internet using an URL instead of a file name. In addition, you can apply filters on the images before sending them to the GPU, allowing video effect: blue screen, color band, gray, normal map. <code>VideoTexture</code> uses FFmpeg to load images and videos. All the formats and codecs that FFmpeg supports are supported by <code>VideoTexture</code>, including but not limited to:
*AVI
*Ogg
*Xvid
*Theora
*dv1394 camera
*video4linux capture card (this includes many webcams)
*videoForWindows capture card (this includes many webcams)
*JPG
{{clr}}

==Changes to VideoTexture in Blender 2.6==
The <code>VideoTexture</code> module is now simply called <code>bge.texture</code>.

==How it works==
The principle is simple: first you identify an existing texture by object and name, then you create a new texture with dynamic content and swap the two textures in the GPU. The GE is not aware of the substitution and continues to display the object as always, except that you are now in control of the texture. At the end, the new texture is deleted and the old texture restored.

The present page is a guide to the <code>VideoTexture</code> module with simple examples.
{{clr}}

==Game preparation==
Before you can use the thing <code>VideoTexture</code> module, you must have objects with textures applied appropriately.

Imagine you want to have a television showing live broadcast programs in the game. You will create a television object and UV-apply a different texture at the place of the screen, for example “<code>tv.png</code>”. What this texture looks like is not important; probably you want to make it dark grey to simulate power-off state. When the television must be turned on, you create a dynamic texture from a video capture card and use it instead of <code>tv.png</code>: the TV screen will come to life.

You have two ways to define textures that <code>VideoTexture</code> can grab:
#Simple UV texture.
#Blender material with image texture channel.

Because <code>VideoTexture</code> works at texture level, it is compatible with all GE fancy texturing features: GLSL, multi-texture, custom shaders, etc.
{{clr}}

==First example==
Let’s assume that we have a game object with one or more faces assigned to a material/image on which we want to display a video.

The first step is to create a <code>Texture</code> object. We will do it in a script that runs once. It can be at the start of the game, the video is only played when you refresh the texture; we’ll come to that later. The script is normally attached to the object on which we want to display the video so that we can easily retrieve the object reference:
<source lang="python">
import VideoTexture

contr = GameLogic.getCurrentController()
obj = contr.owner

if not hasattr(GameLogic, 'video'):
</source>

The check on “<code>video</code>” attribute is just a trick to make sure we create the texture only once.
{{clr}}

===Find material===
<source lang="python">
matID = VideoTexture.materialID(obj, 'IMvideo.png')
</source>

<code>VideoTexture.materialID()</code> is a handy function to retrieve the object material that is using <code>video.png</code> as texture. This method will work with Blender material and UV texture. In case of UV texture, it grabs the internal material corresponding to the faces that are assigned to this texture. In case of Blender material, it grabs the material that has an image texture channel matching the name as first channel.

The “<code>IM</code>” prefix indicates that we’re searching for a texture name but we can also search for a material by giving the “<code>MA</code>” prefix. For example, if we want to find the material called <code>VideoMat</code> on this object, the code becomes:
<source lang="python">
matID = VideoTexture.materialID(obj, 'MAVideoMat')
</source>
{{clr}}

===Create texture===
<code>VideoTexture.Texture</code> is the class that creates the <code>Texture</code> object that loads the dynamic texture on the GPU. The constructor takes one mandatory and three optional arguments:

;<code>gameObj</code>
:The game object.

;<code>materialID</code>
:Material index as returned by <code>VideoTexture.materialID()</code>, 0 = first material by default.

;<code>textureID</code>
:Texture index in case of multi-texture channel, 0 = first channel by default.
:In case of UV texture, this parameter should always be 0.

;<code>textureObj</code>
:Reference to another <code>Texture</code> object of which we want to reuse the texture.
:If we use this argument, we should not create any source on this texture and there is no need to refresh it either: the other <code>Texture</code> object will provide the texture for both materials/textures.

<source lang="python">
GameLogic.video = VideoTexture.Texture(obj, matID)
</source>
{{clr}}

===Make texture persistent===
Note that we have assigned the object to a <code>GameLogic</code> “<code>video</code>” attribute that we create for the occasion. The reason is that the <code>Texture</code> object must be persistent across the game scripts. A local variable would be deleted at the end of the script and the GPU texture deleted at the same time. <code>GameLogic</code> module object is a handy place to store persistent objects.
{{clr}}

===Create a source===
Now we have a <code>Texture</code> object but it can’t do anything because it does not have any source. We must create a source object from one of the possible sources available in <code>VideoTexture</code>:

;<code>VideoFFmpeg</code>
:Moving pictures.
:Video file, video capture, video streaming.

;<code>ImageFFmpeg</code>
:Still pictures.
:Image file, image on web.

;<code>ImageBuff</code>
:Image from application memory.
:For computer generated images, drawing applications.

;<code>ImageViewport</code>
:Part or whole of the viewport (=rendering of the active camera displayed on screen).

;<code>ImageRender</code>
:Render of a non active camera.

;<code>ImageMix</code>
:A mix of 2 or more of the above sources.

In this example we use a simple video file as source. The <code>VideoFFmpeg</code> constructor takes a file name as argument. To avoid any confusion with the location of the file, we will use <code>GameLogic.expandPath()</code> to build an absolute file name, assuming the video file is in the same directory as the blend file:
<source lang="python">
movie = GameLogic.expandPath('//trailer_400p.ogg')
GameLogic.video.source = VideoTexture.VideoFFmpeg(movie)
</source>

We create the video source object and assign it to the <code>Texture</code> object <code>source</code> attribute to set the source and make it persistent: as the <code>Texture</code> object is persistent, the source object will also be persistent.

Note that we can change the <code>Texture</code> source at any time. Suppose we want to switch between two movies during the game. We can do the following:
<source lang="python">
GameLogic.mySources[0] = VideoTexture.VideoFFmpeg('movie1.avi')
GameLogic.mySources[1] = VideoTexture.VideoFFmpeg('movie2.avi')
</source>

And then assign (and reassign) the source during the game:
<source lang="python">
GameLogic.video.source = GameLogic.mySources[movieSel]
</source>
{{clr}}

===Setup the source===
The <code>VideoFFmpeg</code> source has several attributes to control the movie playback:

;<code>range</code>
:[start,stop] (''floats'').
:Set the start and stop time of the video playback, expressed in seconds from beginning. By default the entire video.

;<code>repeat</code>
:(''integer'').
:Number of video replay, -1 for infinite.

;<code>framerate</code>
:(''float'').
:Relative frame rate, <1.0 for slow, >1.0 for fast.

;<code>scale</code>
:(''bool'').
:Set to True to activate fast nearest neighbour scaling algorithm.
:Texture width and height must be a power of 2. If the video picture size is not a power of 2, rescaling is required. By default <code>VideoTexture</code> uses the precise but slow <code>gluScaleImage()</code> function. Best is to rescale the video offline so that no scaling is necessary at runtime!

;<code>flip</code>
:(''bool'').
:Set to True if the image must be vertically flipped.
:FFmpeg always delivers the image upside down, so this attribute is set to True by default.

;<code>filter</code>
:Set additional filter on the video before sending to GPU.
:Assign to one of <code>VideoTexture</code> filter object. By default the image is send unchanged to the GPU. If an alpha channel is present in the video, it is automatically loaded and sent to the GPU as well.

We will simply set the <code>scale</code> attribute to True because the <code>gluScaleImage()</code> is really too slow for real time video. In case the video dimensions are already a power of 2, it has no effect.
<source lang="python">
GameLogic.video.source.scale = True
</source>
{{clr}}

===Play the video===
We are now ready to play the video:
<source lang="python">
GameLogic.video.source.play()
</source>

Video playback is not a background process: it happens only when we refresh the texture. So we must have another script that runs on every frame and calls the <code>refresh()</code> method of the <code>Texture</code> object:
<source lang="python">
if hasattr(GameLogic, 'video'):
GameLogic.video.refresh(True)
</source>

If the video source is stopped, <code>refresh()</code> has no effect. The argument of <code>refresh()</code> is a flag that indicates if the texture should be recalculated on next refresh. For video playback, you definitively want to set it to True.
{{clr}}

===Checking video status===

Video source classes (such as VideoFFMpeg) have an attribute <code>status</code>. If video is playing, its value is 2, if it's stopped, it's 3. So in our example:
<source lang="python">
if GameLogic.video.source.status == 3:
#video has stopped
</source>

===Advanced work flow===
True argument in <code>Texture.refresh()</code> method simply invalidates the image buffer after sending it to the GPU so that on next frame, a new image will be loaded from the source. It has the side effect of making the image unavailable to Python. You can also do it manually by calling the <code>refresh()</code> method of the source directly.

Here are some possible advanced work flow:
*Use the image buffer in python (doesn't effect the Texture):
<source lang="python">
GameLogic.video.refresh(False)
image = GameLogic.video.source.image
# image is a binary string buffer of row major RGBA pixels
# ... use image
# invalidates it for next frame
GameLogic.video.source.refresh()
</source>

*Load image from source for python processing wihtout download to GPU:
# note that we don't even call refresh on the Texture
# we could also just create a source object without a Texture object
<source lang="python">
image = GameLogic.video.source.image
# ... use image
GameLogic.video.source.refresh()
</source>

*If you have more than 1 material on the mesh and you want to modify a texture of one particular material, get its ID
<source lang="python">
matID=VideoTexture.materialID(gameobj,"MAmat.001")
</source>
GLSL material can have more than 1 texture channel, identify the texture by the texture slot where it is defined, here 2
<source lang="python">
tex=VideoTexture.Texture(gameobj, matID, 2)
</source>
{{clr}}

==Advanced demos==
Here is a [http://www.graphicall.org/ftp/ben2610/VideoTextureDemo2video.blend demo] that demonstrates the use of two videos alternatively on the same texture. Note that it requires an additional video file which is the elephant dream teaser. You can replace with another other file that you want to run the demo.

Here is a [http://www.graphicall.org/ftp/ben2610/VideoTextureDemo2videoMix.blend demo] that demonstrates the use of the <code>ImageMix</code> source. <code>ImageMix</code> is a source that needs sources, which can be any other <code>Texture</code> source, like <code>VideoFFmpeg</code>, <code>ImageFFmpeg</code> or <code>ImageRender</code>. You set them with <code>setSource()</code> and their relative weight with <code>setWeight()</code>. Pay attention that the weight is a short number between 0 and 255, and that the sum of all weights should be 255. <code>ImageMix</code> makes a mix of all the sources according to their weights. The sources must all have the same image size (after reduction to the nearest power of 2 dimension). If they don’t, you get a Python error on the console.
{{clr}}

{{Page/Footer|Doc:2.5/Manual/Game Engine/Python API/Bullet physics|Doc:2.5/Manual/Game Engine/Features}}

[[Category:Game engine]]
[[Category:Python]]
[[Category:API's]]

← 古い版	2018年6月28日 (木) 19:45時点における版
(相違点なし)

Doc:2.6/Manual/Game Engine/Python API/VideoTexture - 版の履歴

Yamyam: 1版 をインポートしました

wiki>Ndelgrosso: /* Download the demo */ Link Broken.

Yamyam: 1版をインポートしました