archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
c52170b4ed83a279af5d1a065d173969fe3d24cd
blender-archive/source/blender/python/api2_2x/sceneRender.c
Ton Roosendaal c52170b4ed Patch provided by Alfredo de Greef 
This adds Radiance HDR image file support. So now at least we can save
the 'fbuf' (4x32 bits float colors) in Blender.
It doesn't change anything for internal support in imbuf for floa colors,
so when reading .hdr files it still converts it to 32 bits RGBA.

As an extra I've added that saving images with F3 now also adds the
optional extension, when the F10 "Extensions" option is set.

One important note; I don't know the proper license for the code, it was
provided without... will await feedback from Alfredo about it. For now
I've added the standard Blender GPL header.
2005-11-20 14:32:07 +00:00

2124 lines
75 KiB
C
Raw Blame History

/*
* $Id$
*
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
*
* This program is free software; you can Redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version. The Blender
* Foundation also sells licenses for use in proprietary software under
* the Blender License. See http://www.blender.org/BL/ for information
* about this.
*
* 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 General Public License for more details.
*
* You should have received a copy of the GNU 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.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* This is a new part of Blender.
*
* Contributor(s): Joseph Gilbert
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
struct View3D; /* keep me up here */
#include "sceneRender.h" /*This must come first*/
#include "BIF_renderwin.h"
#include "DNA_image_types.h"
#include "BIF_drawscene.h"
#include "BLI_blenlib.h"
#include "BKE_image.h"
#include "BKE_global.h"
#include "mydevice.h"
#include "butspace.h"
#include "render.h" /* RE_animrender() */
#include "blendef.h"
#include "gen_utils.h"
//local defines
#define PY_NONE 0
#define PY_LOW 1
#define PY_MEDIUM 2
#define PY_HIGH 3
#define PY_HIGHER 4
#define PY_BEST 5
#define PY_SKYDOME 1
#define PY_FULL 2
extern RE_Render R;
extern void schrijfplaatje(char *name);
extern void waitcursor(int);
//---------------------------------------Render prototypes-------------
static PyObject *M_Render_CloseRenderWindow( PyObject * self );
static PyObject *M_Render_EnableDispView( PyObject * self );
static PyObject *M_Render_EnableDispWin( PyObject * self );
static PyObject *M_Render_SetRenderWinPos( PyObject * self, PyObject * args );
static PyObject *M_Render_EnableEdgeShift( PyObject * self, PyObject * args );
static PyObject *M_Render_EnableEdgeAll( PyObject * self, PyObject * args );
//----------------------------------------------Render doc strings------
static char M_Render_doc[] = "The Blender Render module";
//----------------------------------------------Render method def-------
struct PyMethodDef M_Render_methods[] = {
{"CloseRenderWindow", ( PyCFunction ) M_Render_CloseRenderWindow,
METH_NOARGS,
"() - close the rendering window\n"},
{"EnableDispView", ( PyCFunction ) M_Render_EnableDispView,
METH_NOARGS,
"(bool) - enable Sceneing in view\n"},
{"EnableDispWin", ( PyCFunction ) M_Render_EnableDispWin, METH_NOARGS,
"(bool) - enable Sceneing in new window\n"},
{"SetRenderWinPos", ( PyCFunction ) M_Render_SetRenderWinPos,
METH_VARARGS,
"([string list]) - position the rendering window in around the edge of the screen\n"},
{"EnableEdgeShift", ( PyCFunction ) M_Render_EnableEdgeShift,
METH_VARARGS,
"(bool) - with the unified renderer the outlines are shifted a bit.\n"},
{"EnableEdgeAll", ( PyCFunction ) M_Render_EnableEdgeAll, METH_VARARGS,
"(bool) - also consider transparent faces for edge-rendering with the unified renderer\n"},
{NULL, NULL, 0, NULL}
};
//------------------------------------BPy_RenderData methods/callbacks--
static PyObject *RenderData_Render( BPy_RenderData * self );
static PyObject *RenderData_SaveRenderedImage( BPy_RenderData *self, PyObject *args);
static PyObject *RenderData_RenderAnim( BPy_RenderData * self );
static PyObject *RenderData_Play( BPy_RenderData * self );
static PyObject *RenderData_SetRenderPath( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_GetRenderPath( BPy_RenderData * self );
static PyObject *RenderData_SetBackbufPath( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_GetBackbufPath( BPy_RenderData * self );
static PyObject *RenderData_EnableBackbuf( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_SetFtypePath( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_GetFtypePath( BPy_RenderData * self );
static PyObject *RenderData_EnableExtensions( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableSequencer( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableRenderDaemon( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableToonShading( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EdgeIntensity( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_SetEdgeColor( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_GetEdgeColor( BPy_RenderData * self );
static PyObject *RenderData_EdgeAntiShift( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableOversampling( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_SetOversamplingLevel( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableMotionBlur( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_MotionBlurLevel( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_PartsX( BPy_RenderData * self, PyObject * args );
static PyObject *RenderData_PartsY( BPy_RenderData * self, PyObject * args );
static PyObject *RenderData_EnableSky( BPy_RenderData * self );
static PyObject *RenderData_EnablePremultiply( BPy_RenderData * self );
static PyObject *RenderData_EnableKey( BPy_RenderData * self );
static PyObject *RenderData_EnableShadow( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnablePanorama( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableEnvironmentMap( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableRayTracing( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableRadiosityRender( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_SetRenderWinSize( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableFieldRendering( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableOddFieldFirst( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableFieldTimeDisable( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableGaussFilter( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableBorderRender( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_SetBorder( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableGammaCorrection( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_GaussFilterSize( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_StartFrame( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_CurrentFrame( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EndFrame( BPy_RenderData * self, PyObject * args );
static PyObject *RenderData_ImageSizeX( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_ImageSizeY( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_AspectRatioX( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_AspectRatioY( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_SetRenderer( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableCropping( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_SetImageType( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_Quality( BPy_RenderData * self, PyObject * args );
static PyObject *RenderData_FramesPerSec( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableGrayscale( BPy_RenderData * self );
static PyObject *RenderData_EnableRGBColor( BPy_RenderData * self );
static PyObject *RenderData_EnableRGBAColor( BPy_RenderData * self );
static PyObject *RenderData_SizePreset( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableUnifiedRenderer( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_SetYafrayGIQuality( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_SetYafrayGIMethod( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayGIPower( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayGIDepth( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayGICDepth( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableYafrayGICache( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableYafrayGIPhotons( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayGIPhotonCount( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayGIPhotonRadius( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayGIPhotonMixCount( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableYafrayGITunePhotons( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayGIShadowQuality( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayGIPixelsPerSample( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayGIRefinement( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayRayBias( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayRayDepth( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayGamma( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayExposure( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_YafrayProcessorCount( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableGameFrameStretch( BPy_RenderData * self );
static PyObject *RenderData_EnableGameFrameExpose( BPy_RenderData * self );
static PyObject *RenderData_EnableGameFrameBars( BPy_RenderData * self );
static PyObject *RenderData_SetGameFrameColor( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_GetGameFrameColor( BPy_RenderData * self );
static PyObject *RenderData_GammaLevel( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_PostProcessAdd( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_PostProcessMultiply( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_PostProcessGamma( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_SGIMaxsize( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_EnableSGICosmo( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_OldMapValue( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_NewMapValue( BPy_RenderData * self,
PyObject * args );
static PyObject *RenderData_getTimeCode( BPy_RenderData * self);
static void RenderData_dealloc( BPy_RenderData * self );
static PyObject *RenderData_getAttr( BPy_RenderData * self, char *name );
static PyObject *RenderData_repr( BPy_RenderData * self );
//------------------------------------BPy_RenderData method def--------
static PyMethodDef BPy_RenderData_methods[] = {
{"render", ( PyCFunction ) RenderData_Render, METH_NOARGS,
"() - render the scene\n"},
{"saveRenderedImage", (PyCFunction)RenderData_SaveRenderedImage, METH_VARARGS,
"(filename) - save an image generated by a call to render() (set output path first)\n"},
{"renderAnim", ( PyCFunction ) RenderData_RenderAnim, METH_NOARGS,
"() - render a sequence from start frame to end frame\n"},
{"play", ( PyCFunction ) RenderData_Play, METH_NOARGS,
"() - play animation of rendered images/avi (searches Pics: field)\n"},
{"setRenderPath", ( PyCFunction ) RenderData_SetRenderPath,
METH_VARARGS,
"(string) - get/set the path to output the rendered images to\n"},
{"getRenderPath", ( PyCFunction ) RenderData_GetRenderPath,
METH_NOARGS,
"() - get the path to directory where rendered images will go\n"},
{"setBackbufPath", ( PyCFunction ) RenderData_SetBackbufPath,
METH_VARARGS,
"(string) - get/set the path to a background image and load it\n"},
{"getBackbufPath", ( PyCFunction ) RenderData_GetBackbufPath,
METH_NOARGS,
"() - get the path to background image file\n"},
{"enableBackbuf", ( PyCFunction ) RenderData_EnableBackbuf,
METH_VARARGS,
"(bool) - enable/disable the backbuf image\n"},
{"setFtypePath", ( PyCFunction ) RenderData_SetFtypePath, METH_VARARGS,
"(string) - get/set the path to output the Ftype file\n"},
{"getFtypePath", ( PyCFunction ) RenderData_GetFtypePath, METH_NOARGS,
"() - get the path to Ftype file\n"},
{"enableExtensions", ( PyCFunction ) RenderData_EnableExtensions,
METH_VARARGS,
"(bool) - enable/disable windows extensions for output files\n"},
{"enableSequencer", ( PyCFunction ) RenderData_EnableSequencer,
METH_VARARGS,
"(bool) - enable/disable Do Sequence\n"},
{"enableRenderDaemon", ( PyCFunction ) RenderData_EnableRenderDaemon,
METH_VARARGS,
"(bool) - enable/disable Scene daemon\n"},
{"enableToonShading", ( PyCFunction ) RenderData_EnableToonShading,
METH_VARARGS,
"(bool) - enable/disable Edge rendering\n"},
{"edgeIntensity", ( PyCFunction ) RenderData_EdgeIntensity,
METH_VARARGS,
"(int) - get/set edge intensity for toon shading\n"},
{"setEdgeColor", ( PyCFunction ) RenderData_SetEdgeColor, METH_VARARGS,
"(f,f,f) - set the edge color for toon shading - Red,Green,Blue expected.\n"},
{"getEdgeColor", ( PyCFunction ) RenderData_GetEdgeColor, METH_NOARGS,
"() - get the edge color for toon shading - Red,Green,Blue expected.\n"},
{"edgeAntiShift", ( PyCFunction ) RenderData_EdgeAntiShift,
METH_VARARGS,
"(int) - with the unified renderer to reduce intensity on boundaries.\n"},
{"enableOversampling", ( PyCFunction ) RenderData_EnableOversampling,
METH_VARARGS,
"(bool) - enable/disable oversampling (anit-aliasing).\n"},
{"setOversamplingLevel",
( PyCFunction ) RenderData_SetOversamplingLevel, METH_VARARGS,
"(enum) - get/set the level of oversampling (anit-aliasing).\n"},
{"enableMotionBlur", ( PyCFunction ) RenderData_EnableMotionBlur,
METH_VARARGS,
"(bool) - enable/disable MBlur.\n"},
{"motionBlurLevel", ( PyCFunction ) RenderData_MotionBlurLevel,
METH_VARARGS,
"(float) - get/set the length of shutter time for motion blur.\n"},
{"partsX", ( PyCFunction ) RenderData_PartsX, METH_VARARGS,
"(int) - get/set the number of parts to divide the render in the X direction\n"},
{"partsY", ( PyCFunction ) RenderData_PartsY, METH_VARARGS,
"(int) - get/set the number of parts to divide the render in the Y direction\n"},
{"enableSky", ( PyCFunction ) RenderData_EnableSky, METH_NOARGS,
"() - enable render background with sky\n"},
{"enablePremultiply", ( PyCFunction ) RenderData_EnablePremultiply,
METH_NOARGS,
"() - enable premultiply alpha\n"},
{"enableKey", ( PyCFunction ) RenderData_EnableKey, METH_NOARGS,
"() - enable alpha and colour values remain unchanged\n"},
{"enableShadow", ( PyCFunction ) RenderData_EnableShadow, METH_VARARGS,
"(bool) - enable/disable shadow calculation\n"},
{"enablePanorama", ( PyCFunction ) RenderData_EnablePanorama,
METH_VARARGS,
"(bool) - enable/disable panorama rendering (output width is multiplied by Xparts)\n"},
{"enableEnvironmentMap",
( PyCFunction ) RenderData_EnableEnvironmentMap, METH_VARARGS,
"(bool) - enable/disable environment map rendering\n"},
{"enableRayTracing", ( PyCFunction ) RenderData_EnableRayTracing,
METH_VARARGS,
"(bool) - enable/disable ray tracing\n"},
{"enableRadiosityRender",
( PyCFunction ) RenderData_EnableRadiosityRender, METH_VARARGS,
"(bool) - enable/disable radiosity rendering\n"},
{"setRenderWinSize", ( PyCFunction ) RenderData_SetRenderWinSize,
METH_VARARGS,
"(enum) - get/set the size of the render window\n"},
{"enableFieldRendering",
( PyCFunction ) RenderData_EnableFieldRendering, METH_VARARGS,
"(bool) - enable/disable field rendering\n"},
{"enableOddFieldFirst", ( PyCFunction ) RenderData_EnableOddFieldFirst,
METH_VARARGS,
"(bool) - enable/disable Odd field first rendering (Default: Even field)\n"},
{"enableFieldTimeDisable",
( PyCFunction ) RenderData_EnableFieldTimeDisable, METH_VARARGS,
"(bool) - enable/disable time difference in field calculations\n"},
{"enableGaussFilter", ( PyCFunction ) RenderData_EnableGaussFilter,
METH_VARARGS,
"(bool) - enable/disable Gauss sampling filter for antialiasing\n"},
{"enableBorderRender", ( PyCFunction ) RenderData_EnableBorderRender,
METH_VARARGS,
"(bool) - enable/disable small cut-out rendering\n"},
{"setBorder", ( PyCFunction ) RenderData_SetBorder, METH_VARARGS,
"(f,f,f,f) - set the border for border rendering\n"},
{"enableGammaCorrection",
( PyCFunction ) RenderData_EnableGammaCorrection, METH_VARARGS,
"(bool) - enable/disable gamma correction\n"},
{"gaussFilterSize", ( PyCFunction ) RenderData_GaussFilterSize,
METH_VARARGS,
"(float) - get/sets the Gauss filter size\n"},
{"startFrame", ( PyCFunction ) RenderData_StartFrame, METH_VARARGS,
"(int) - get/set the starting frame for rendering\n"},
{"currentFrame", ( PyCFunction ) RenderData_CurrentFrame, METH_VARARGS,
"(int) - get/set the current frame for rendering\n"},
{"endFrame", ( PyCFunction ) RenderData_EndFrame, METH_VARARGS,
"(int) - get/set the ending frame for rendering\n"},
{"getTimeCode", ( PyCFunction ) RenderData_getTimeCode, METH_NOARGS,
"get the current frame in HH:MM:SS:FF format\n"},
{"imageSizeX", ( PyCFunction ) RenderData_ImageSizeX, METH_VARARGS,
"(int) - get/set the image width in pixels\n"},
{"imageSizeY", ( PyCFunction ) RenderData_ImageSizeY, METH_VARARGS,
"(int) - get/set the image height in pixels\n"},
{"aspectRatioX", ( PyCFunction ) RenderData_AspectRatioX, METH_VARARGS,
"(int) - get/set the horizontal aspect ratio\n"},
{"aspectRatioY", ( PyCFunction ) RenderData_AspectRatioY, METH_VARARGS,
"(int) - get/set the vertical aspect ratio\n"},
{"setRenderer", ( PyCFunction ) RenderData_SetRenderer, METH_VARARGS,
"(enum) - get/set which renderer to render the output\n"},
{"enableCropping", ( PyCFunction ) RenderData_EnableCropping,
METH_VARARGS,
"(bool) - enable/disable exclusion of border rendering from total image\n"},
{"setImageType", ( PyCFunction ) RenderData_SetImageType, METH_VARARGS,
"(enum) - get/set the type of image to output from the render\n"},
{"quality", ( PyCFunction ) RenderData_Quality, METH_VARARGS,
"(int) - get/set quality get/setting for JPEG images, AVI Jpeg and SGI movies\n"},
{"framesPerSec", ( PyCFunction ) RenderData_FramesPerSec, METH_VARARGS,
"(int) - get/set frames per second\n"},
{"enableGrayscale", ( PyCFunction ) RenderData_EnableGrayscale,
METH_NOARGS,
"() - images are saved with BW (grayscale) data\n"},
{"enableRGBColor", ( PyCFunction ) RenderData_EnableRGBColor,
METH_NOARGS,
"() - images are saved with RGB (color) data\n"},
{"enableRGBAColor", ( PyCFunction ) RenderData_EnableRGBAColor,
METH_NOARGS,
"() - images are saved with RGB and Alpha data (if supported)\n"},
{"sizePreset", ( PyCFunction ) RenderData_SizePreset, METH_VARARGS,
"(enum) - get/set the render to one of a few preget/sets\n"},
{"enableUnifiedRenderer",
( PyCFunction ) RenderData_EnableUnifiedRenderer, METH_VARARGS,
"(bool) - use the unified renderer\n"},
{"setYafrayGIQuality", ( PyCFunction ) RenderData_SetYafrayGIQuality,
METH_VARARGS,
"(enum) - get/set yafray global Illumination quality\n"},
{"setYafrayGIMethod", ( PyCFunction ) RenderData_SetYafrayGIMethod,
METH_VARARGS,
"(enum) - get/set yafray global Illumination method\n"},
{"yafrayGIPower", ( PyCFunction ) RenderData_YafrayGIPower,
METH_VARARGS,
"(float) - get/set GI lighting intensity scale\n"},
{"yafrayGIDepth", ( PyCFunction ) RenderData_YafrayGIDepth,
METH_VARARGS,
"(int) - get/set number of bounces of the indirect light\n"},
{"yafrayGICDepth", ( PyCFunction ) RenderData_YafrayGICDepth,
METH_VARARGS,
"(int) - get/set number of bounces inside objects (for caustics)\n"},
{"enableYafrayGICache", ( PyCFunction ) RenderData_EnableYafrayGICache,
METH_VARARGS,
"(bool) - enable/disable cache irradiance samples (faster)\n"},
{"enableYafrayGIPhotons",
( PyCFunction ) RenderData_EnableYafrayGIPhotons, METH_VARARGS,
"(bool) - enable/disable use global photons to help in GI\n"},
{"yafrayGIPhotonCount", ( PyCFunction ) RenderData_YafrayGIPhotonCount,
METH_VARARGS,
"(int) - get/set number of photons to shoot\n"},
{"yafrayGIPhotonRadius",
( PyCFunction ) RenderData_YafrayGIPhotonRadius, METH_VARARGS,
"(float) - get/set radius to search for photons to mix (blur)\n"},
{"yafrayGIPhotonMixCount",
( PyCFunction ) RenderData_YafrayGIPhotonMixCount, METH_VARARGS,
"(int) - get/set number of photons to shoot\n"},
{"enableYafrayGITunePhotons",
( PyCFunction ) RenderData_EnableYafrayGITunePhotons, METH_VARARGS,
"(bool) - enable/disable show the photonmap directly in the render for tuning\n"},
{"yafrayGIShadowQuality",
( PyCFunction ) RenderData_YafrayGIShadowQuality, METH_VARARGS,
"(float) - get/set the shadow quality, keep it under 0.95\n"},
{"yafrayGIPixelsPerSample",
( PyCFunction ) RenderData_YafrayGIPixelsPerSample, METH_VARARGS,
"(int) - get/set maximum number of pixels without samples, the lower the better and slower\n"},
{"yafrayGIRefinement", ( PyCFunction ) RenderData_YafrayGIRefinement,
METH_VARARGS,
"(float) - get/setthreshold to refine shadows EXPERIMENTAL. 1 = no refinement\n"},
{"yafrayRayBias", ( PyCFunction ) RenderData_YafrayRayBias,
METH_VARARGS,
"(float) - get/set shadow ray bias to avoid self shadowing\n"},
{"yafrayRayDepth", ( PyCFunction ) RenderData_YafrayRayDepth,
METH_VARARGS,
"(int) - get/set maximum render ray depth from the camera\n"},
{"yafrayGamma", ( PyCFunction ) RenderData_YafrayGamma, METH_VARARGS,
"(float) - get/set gamma correction, 1 is off\n"},
{"yafrayExposure", ( PyCFunction ) RenderData_YafrayExposure,
METH_VARARGS,
"(float) - get/set exposure adjustment, 0 is off\n"},
{"yafrayProcessorCount",
( PyCFunction ) RenderData_YafrayProcessorCount, METH_VARARGS,
"(int) - get/set number of processors to use\n"},
{"enableGameFrameStretch",
( PyCFunction ) RenderData_EnableGameFrameStretch, METH_NOARGS,
"(l) - enble stretch or squeeze the viewport to fill the display window\n"},
{"enableGameFrameExpose",
( PyCFunction ) RenderData_EnableGameFrameExpose, METH_NOARGS,
"(l) - enable show the entire viewport in the display window, viewing more horizontally or vertically\n"},
{"enableGameFrameBars", ( PyCFunction ) RenderData_EnableGameFrameBars,
METH_NOARGS,
"() - enable show the entire viewport in the display window, using bar horizontally or vertically\n"},
{"setGameFrameColor", ( PyCFunction ) RenderData_SetGameFrameColor,
METH_VARARGS,
"(f,f,f) - set the red, green, blue component of the bars\n"},
{"getGameFrameColor", ( PyCFunction ) RenderData_GetGameFrameColor,
METH_NOARGS,
"() - get the red, green, blue component of the bars\n"},
{"gammaLevel", ( PyCFunction ) RenderData_GammaLevel, METH_VARARGS,
"(float) - get/set the gamma value for blending oversampled images (1.0 = no correction\n"},
{"postProcessAdd", ( PyCFunction ) RenderData_PostProcessAdd,
METH_VARARGS,
"(float) - get/set post processing add\n"},
{"postProcessMultiply", ( PyCFunction ) RenderData_PostProcessMultiply,
METH_VARARGS,
"(float) - get/set post processing multiply\n"},
{"postProcessGamma", ( PyCFunction ) RenderData_PostProcessGamma,
METH_VARARGS,
"(float) - get/set post processing gamma\n"},
{"SGIMaxsize", ( PyCFunction ) RenderData_SGIMaxsize, METH_VARARGS,
"(int) - get/set maximum size per frame to save in an SGI movie\n"},
{"enableSGICosmo", ( PyCFunction ) RenderData_EnableSGICosmo,
METH_VARARGS,
"(bool) - enable/disable attempt to save SGI movies using Cosmo hardware\n"},
{"oldMapValue", ( PyCFunction ) RenderData_OldMapValue, METH_VARARGS,
"(int) - get/set specify old map value in frames\n"},
{"newMapValue", ( PyCFunction ) RenderData_NewMapValue, METH_VARARGS,
"(int) - get/set specify new map value in frames\n"},
{NULL, NULL, 0, NULL}
};
//------------------------------------BPy_RenderData Type defintion------
PyTypeObject RenderData_Type = {
PyObject_HEAD_INIT( NULL ) 0, /* ob_size */
"Blender RenderData", /* tp_name */
sizeof( BPy_RenderData ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
( destructor ) RenderData_dealloc, /* tp_dealloc */
0, /* tp_print */
( getattrfunc ) RenderData_getAttr, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
( reprfunc ) RenderData_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_as_hash */
0, 0, 0, 0, 0, 0,
0, /* tp_doc */
0, 0, 0, 0, 0, 0,
BPy_RenderData_methods, /* tp_methods */
0, /* tp_members */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};
//---------------------------------------------------Render Module Init--
PyObject *Render_Init( void )
{
PyObject *submodule;
RenderData_Type.ob_type = &PyType_Type;
submodule = Py_InitModule3( "Blender.Scene.Render",
M_Render_methods, M_Render_doc );
PyModule_AddIntConstant( submodule, "INTERNAL", R_INTERN );
PyModule_AddIntConstant( submodule, "YAFRAY", R_YAFRAY );
PyModule_AddIntConstant( submodule, "AVIRAW", R_AVIRAW );
PyModule_AddIntConstant( submodule, "AVIJPEG", R_AVIJPEG );
PyModule_AddIntConstant( submodule, "AVICODEC", R_AVICODEC );
PyModule_AddIntConstant( submodule, "QUICKTIME", R_QUICKTIME );
PyModule_AddIntConstant( submodule, "TARGA", R_TARGA );
PyModule_AddIntConstant( submodule, "RAWTGA", R_RAWTGA );
PyModule_AddIntConstant( submodule, "HDR", R_RADHDR );
PyModule_AddIntConstant( submodule, "PNG", R_PNG );
PyModule_AddIntConstant( submodule, "BMP", R_BMP );
PyModule_AddIntConstant( submodule, "JPEG", R_JPEG90 );
PyModule_AddIntConstant( submodule, "HAMX", R_HAMX );
PyModule_AddIntConstant( submodule, "IRIS", R_IRIS );
PyModule_AddIntConstant( submodule, "IRISZ", R_IRIZ );
PyModule_AddIntConstant( submodule, "FTYPE", R_FTYPE );
PyModule_AddIntConstant( submodule, "PAL", B_PR_PAL );
PyModule_AddIntConstant( submodule, "NTSC", B_PR_NTSC );
PyModule_AddIntConstant( submodule, "DEFAULT", B_PR_PRESET );
PyModule_AddIntConstant( submodule, "PREVIEW", B_PR_PRV );
PyModule_AddIntConstant( submodule, "PC", B_PR_PC );
PyModule_AddIntConstant( submodule, "PAL169", B_PR_PAL169 );
PyModule_AddIntConstant( submodule, "PANO", B_PR_PANO );
PyModule_AddIntConstant( submodule, "FULL", B_PR_FULL );
PyModule_AddIntConstant( submodule, "NONE", PY_NONE );
PyModule_AddIntConstant( submodule, "LOW", PY_LOW );
PyModule_AddIntConstant( submodule, "MEDIUM", PY_MEDIUM );
PyModule_AddIntConstant( submodule, "HIGH", PY_HIGH );
PyModule_AddIntConstant( submodule, "HIGHER", PY_HIGHER );
PyModule_AddIntConstant( submodule, "BEST", PY_BEST );
PyModule_AddIntConstant( submodule, "SKYDOME", PY_SKYDOME );
PyModule_AddIntConstant( submodule, "GIFULL", PY_FULL );
return ( submodule );
}
//-----------------------------------BPy_RenderData Internal Protocols---
//-------------------------------------------------dealloc---------------
static void RenderData_dealloc( BPy_RenderData * self )
{
PyObject_DEL( self );
}
//-------------------------------------------------getAttr---------------
static PyObject *RenderData_getAttr( BPy_RenderData * self, char *name )
{
return Py_FindMethod( BPy_RenderData_methods, ( PyObject * ) self,
name );
}
//-------------------------------------------------repr------------------
static PyObject *RenderData_repr( BPy_RenderData * self )
{
if( self->renderContext )
return PyString_FromFormat( "[RenderData \"%s\"]",
self->scene->id.name + 2 );
else
return PyString_FromString( "NULL" );
}
//------------------------------BPy_RenderData Callbacks-----------------
//--------------------------------------CreatePyObject-------------------
PyObject *RenderData_CreatePyObject( struct Scene * scene )
{
BPy_RenderData *py_renderdata;
py_renderdata =
( BPy_RenderData * ) PyObject_NEW( BPy_RenderData,
&RenderData_Type );
if( py_renderdata == NULL ) {
return ( NULL );
}
py_renderdata->renderContext = &scene->r;
py_renderdata->scene = scene;
return ( ( PyObject * ) py_renderdata );
}
//------------------------------CheckPyObject----------------------------
int RenderData_CheckPyObject( PyObject * py_obj )
{
return ( py_obj->ob_type == &RenderData_Type );
}
//------------------------------------BitToggleInt-----------------------
static PyObject *M_Render_BitToggleInt( PyObject * args, int setting,
int *structure )
{
int flag;
if( !PyArg_ParseTuple( args, "i", &flag ) )
return ( EXPP_ReturnPyObjError
( PyExc_AttributeError,
"expected TRUE or FALSE (1 or 0)" ) );
if( flag < 0 || flag > 1 )
return ( EXPP_ReturnPyObjError
( PyExc_AttributeError,
"expected TRUE or FALSE (1 or 0)" ) );
if( flag )
*structure |= setting;
else
*structure &= ~setting;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------BitToggleShort---------------------
static PyObject *M_Render_BitToggleShort( PyObject * args, short setting,
short *structure )
{
int flag;
if( !PyArg_ParseTuple( args, "i", &flag ) )
return ( EXPP_ReturnPyObjError
( PyExc_AttributeError,
"expected TRUE or FALSE (1 or 0)" ) );
if( flag < 0 || flag > 1 )
return ( EXPP_ReturnPyObjError
( PyExc_AttributeError,
"expected TRUE or FALSE (1 or 0)" ) );
if( flag )
*structure |= setting;
else
*structure &= ~setting;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------GetSetAttributeFloat---------------
static PyObject *M_Render_GetSetAttributeFloat( PyObject * args,
float *structure, float min,
float max )
{
float property = -10.0f;
char error[48];
if( !PyArg_ParseTuple( args, "|f", &property ) )
return ( EXPP_ReturnPyObjError
( PyExc_AttributeError, "expected float" ) );
if( property != -10.0f ) {
if( property < min || property > max ) {
sprintf( error, "out of range - expected %f to %f",
min, max );
return ( EXPP_ReturnPyObjError
( PyExc_AttributeError, error ) );
}
*structure = property;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
} else
return Py_BuildValue( "f", *structure );
}
//------------------------------------GetSetAttributeShort---------------
static PyObject *M_Render_GetSetAttributeShort( PyObject * args,
short *structure, int min,
int max )
{
short property = -10;
char error[48];
if( !PyArg_ParseTuple( args, "|h", &property ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected int" ) );
if( property != -10 ) {
if( property < min || property > max ) {
sprintf( error, "out of range - expected %d to %d",
min, max );
return ( EXPP_ReturnPyObjError
( PyExc_AttributeError, error ) );
}
*structure = property;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
} else
return Py_BuildValue( "h", *structure );
}
//------------------------------------GetSetAttributeInt-----------------
static PyObject *M_Render_GetSetAttributeInt( PyObject * args, int *structure,
int min, int max )
{
int property = -10;
char error[48];
if( !PyArg_ParseTuple( args, "|i", &property ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected int" ) );
if( property != -10 ) {
if( property < min || property > max ) {
sprintf( error, "out of range - expected %d to %d",
min, max );
return ( EXPP_ReturnPyObjError
( PyExc_AttributeError, error ) );
}
*structure = property;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
} else
return Py_BuildValue( "i", *structure );
}
//------------------------------------DoSizePrese -----------------------
static void M_Render_DoSizePreset( BPy_RenderData * self, short xsch,
short ysch, short xasp, short yasp,
short size, short xparts, short yparts,
short frames, float a, float b, float c,
float d )
{
self->renderContext->xsch = xsch;
self->renderContext->ysch = ysch;
self->renderContext->xasp = xasp;
self->renderContext->yasp = yasp;
self->renderContext->size = size;
self->renderContext->frs_sec = frames;
self->renderContext->xparts = xparts;
self->renderContext->yparts = yparts;
BLI_init_rctf( &self->renderContext->safety, a, b, c, d );
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
EXPP_allqueue( REDRAWVIEWCAM, 0 );
}
//------------------------------------Render Module Function Definitions-
//------------------------------------Render.CloseRenderWindow() --------
PyObject *M_Render_CloseRenderWindow( PyObject * self )
{
BIF_close_render_display( );
return EXPP_incr_ret( Py_None );
}
//------------------------------------Render.SetRenderWinPos() ----------
PyObject *M_Render_SetRenderWinPos( PyObject * self, PyObject * args )
{
PyObject *list = NULL;
char *loc = NULL;
int x;
if( !PyArg_ParseTuple( args, "O!", &PyList_Type, &list ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected a list" ) );
G.winpos = 0;
for( x = 0; x < PyList_Size( list ); x++ ) {
if( !PyArg_Parse( PyList_GetItem( list, x ), "s", &loc ) ) {
return EXPP_ReturnPyObjError( PyExc_TypeError,
"python list not parseable\n" );
}
if( strcmp( loc, "SW" ) == 0 || strcmp( loc, "sw" ) == 0 )
G.winpos |= 1;
else if( strcmp( loc, "S" ) == 0 || strcmp( loc, "s" ) == 0 )
G.winpos |= 2;
else if( strcmp( loc, "SE" ) == 0 || strcmp( loc, "se" ) == 0 )
G.winpos |= 4;
else if( strcmp( loc, "W" ) == 0 || strcmp( loc, "w" ) == 0 )
G.winpos |= 8;
else if( strcmp( loc, "C" ) == 0 || strcmp( loc, "c" ) == 0 )
G.winpos |= 16;
else if( strcmp( loc, "E" ) == 0 || strcmp( loc, "e" ) == 0 )
G.winpos |= 32;
else if( strcmp( loc, "NW" ) == 0 || strcmp( loc, "nw" ) == 0 )
G.winpos |= 64;
else if( strcmp( loc, "N" ) == 0 || strcmp( loc, "n" ) == 0 )
G.winpos |= 128;
else if( strcmp( loc, "NE" ) == 0 || strcmp( loc, "ne" ) == 0 )
G.winpos |= 256;
else
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"list contains unknown string\n" );
}
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------Render.EnableDispView() -----------
PyObject *M_Render_EnableDispView( PyObject * self )
{
G.displaymode = R_DISPLAYVIEW;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------Render.EnableDispWin() ------------
PyObject *M_Render_EnableDispWin( PyObject * self )
{
G.displaymode = R_DISPLAYWIN;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------Render.EnableEdgeShift() ----------
PyObject *M_Render_EnableEdgeShift( PyObject * self, PyObject * args )
{
return M_Render_BitToggleInt( args, 1, &G.compat );
}
//------------------------------------Render.EnableEdgeAll() ------------
PyObject *M_Render_EnableEdgeAll( PyObject * self, PyObject * args )
{
return M_Render_BitToggleInt( args, 1, &G.notonlysolid );
}
//----------------------------BPy_RenderData Function Definitions--------
//------------------------------------RenderData.Render() ---------------
PyObject *RenderData_Render( BPy_RenderData * self )
{
Scene *oldsce;
if (!G.background) {
oldsce = G.scene;
set_scene( self->scene );
BIF_do_render( 0 );
set_scene( oldsce );
}
else { /* background mode (blender -b file.blend -P script) */
int end_frame = G.scene->r.efra; /* is of type short currently */
if (G.scene != self->scene)
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
"scene to render in bg mode must be the active scene");
G.scene->r.efra = G.scene->r.sfra;
RE_animrender(NULL);
G.scene->r.efra = (short)end_frame;
}
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.Render() ---------------
//This will save the rendered image to an output file path already defined
PyObject *RenderData_SaveRenderedImage ( BPy_RenderData * self, PyObject *args )
{
char dir[FILE_MAXDIR * 2], str[FILE_MAXFILE * 2], strn[256];
char *name_str, filepath[FILE_MAXDIR+FILE_MAXFILE];
if( !PyArg_ParseTuple( args, "s", &name_str ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected a filename (string)" );
if( strlen(self->renderContext->pic) + strlen(name_str) >
sizeof(filepath)-1 )
return EXPP_ReturnPyObjError( PyExc_ValueError,
"full filename too long" );
BLI_strncpy( filepath, self->renderContext->pic, sizeof(filepath) );
strcat(filepath, name_str);
if(!R.rectot) {
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
"No image rendered");
} else {
if(G.ima[0]==0) {
strcpy(dir, G.sce);
BLI_splitdirstring(dir, str);
strcpy(G.ima, dir);
}
R.r.imtype= G.scene->r.imtype;
R.r.quality= G.scene->r.quality;
R.r.planes= G.scene->r.planes;
strcpy(strn, filepath);
BLI_convertstringcode(strn, G.sce, G.scene->r.cfra);
if(BLI_testextensie(strn,".blend")) {
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
"Wrong filename");
}
waitcursor(1);
schrijfplaatje(strn);
strcpy(G.ima, filepath);
waitcursor(0);
}
return EXPP_incr_ret(Py_None);
}
//------------------------------------RenderData.RenderAnim() -----------
PyObject *RenderData_RenderAnim( BPy_RenderData * self )
{
Scene *oldsce;
if (!G.background) {
oldsce = G.scene;
set_scene( self->scene );
BIF_do_render( 1 );
set_scene( oldsce );
}
else { /* background mode (blender -b file.blend -P script) */
if (G.scene != self->scene)
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
"scene to render in bg mode must be the active scene");
if (G.scene->r.sfra > G.scene->r.efra)
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
"start frame must be less or equal to end frame");
RE_animrender(NULL);
}
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.Play() -----------------
PyObject *RenderData_Play( BPy_RenderData * self )
{
char file[FILE_MAXDIR + FILE_MAXFILE];
extern char bprogname[];
char str[FILE_MAXDIR + FILE_MAXFILE];
int pos[2], size[2];
char txt[64];
#ifdef WITH_QUICKTIME
if( self->renderContext->imtype == R_QUICKTIME ) {
strcpy( file, self->renderContext->pic );
BLI_convertstringcode( file, (char *) self->scene,
self->renderContext->cfra );
RE_make_existing_file( file );
if( BLI_strcasecmp( file + strlen( file ) - 4, ".mov" ) ) {
sprintf( txt, "%04d_%04d.mov",
( self->renderContext->sfra ),
( self->renderContext->efra ) );
strcat( file, txt );
}
} else
#endif
{
strcpy( file, self->renderContext->pic );
BLI_convertstringcode( file, G.sce,
self->renderContext->cfra );
RE_make_existing_file( file );
if( BLI_strcasecmp( file + strlen( file ) - 4, ".avi" ) ) {
sprintf( txt, "%04d_%04d.avi",
( self->renderContext->sfra ),
( self->renderContext->efra ) );
strcat( file, txt );
}
}
if( BLI_exist( file ) ) {
calc_renderwin_rectangle( G.winpos, pos, size );
sprintf( str, "%s -a -p %d %d \"%s\"", bprogname, pos[0],
pos[1], file );
system( str );
} else {
makepicstring( file, self->renderContext->sfra );
if( BLI_exist( file ) ) {
calc_renderwin_rectangle( G.winpos, pos, size );
sprintf( str, "%s -a -p %d %d \"%s\"", bprogname,
pos[0], pos[1], file );
system( str );
} else
sprintf( "Can't find image: %s", file );
}
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.StRenderPath() ---------
PyObject *RenderData_SetRenderPath( BPy_RenderData * self, PyObject * args )
{
char *name;
if( !PyArg_ParseTuple( args, "s", &name ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected a string" ) );
if( strlen( name ) > 160 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"path is too long (SetRenderPath)" ) );
strcpy( self->renderContext->pic, name );
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.GetRenderPath() --------
PyObject *RenderData_GetRenderPath( BPy_RenderData * self )
{
return Py_BuildValue( "s", self->renderContext->pic );
}
//------------------------------------RenderData.SetBackbufPath() -------
PyObject *RenderData_SetBackbufPath( BPy_RenderData * self, PyObject * args )
{
char *name;
Image *ima;
if( !PyArg_ParseTuple( args, "s", &name ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected a string" ) );
if( strlen( name ) > 160 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"path is too long (SetBackbufPath)" ) );
strcpy( self->renderContext->backbuf, name );
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
ima = add_image( name );
if( ima ) {
free_image_buffers( ima );
ima->ok = 1;
}
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.GetBackbufPath() -------
PyObject *RenderData_GetBackbufPath( BPy_RenderData * self )
{
return Py_BuildValue( "s", self->renderContext->backbuf );
}
//------------------------------------RenderData.EnableBackbuf() --------
PyObject *RenderData_EnableBackbuf( BPy_RenderData * self, PyObject * args )
{
return M_Render_BitToggleShort( args, 1,
&self->renderContext->bufflag );
}
//------------------------------------RenderData.SetFtypePath() ---------
PyObject *RenderData_SetFtypePath( BPy_RenderData * self, PyObject * args )
{
char *name;
if( !PyArg_ParseTuple( args, "s", &name ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected a string" ) );
if( strlen( name ) > 160 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"path is too long (SetFtypePath)" ) );
strcpy( self->renderContext->ftype, name );
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.GetFtypePath() ---------
PyObject *RenderData_GetFtypePath( BPy_RenderData * self )
{
return Py_BuildValue( "s", self->renderContext->ftype );
}
//------------------------------------RenderData.EnableExtensions() -----
PyObject *RenderData_EnableExtensions( BPy_RenderData * self, PyObject * args )
{
return M_Render_BitToggleShort( args, R_EXTENSION,
&self->renderContext->scemode );
}
//------------------------------------RenderData.EnableSequencer() ------
PyObject *RenderData_EnableSequencer( BPy_RenderData * self, PyObject * args )
{
return M_Render_BitToggleShort( args, R_DOSEQ,
&self->renderContext->scemode );
}
//------------------------------------RenderData.EnableRenderDaemon() ---
PyObject *RenderData_EnableRenderDaemon( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleShort( args, R_BG_RENDER,
&self->renderContext->scemode );
}
//------------------------------------RenderData.EnableToonShading() ----
PyObject *RenderData_EnableToonShading( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleInt( args, R_EDGE,
&self->renderContext->mode );
}
//------------------------------------RenderData.EdgeIntensity() --------
PyObject *RenderData_EdgeIntensity( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args,
&self->renderContext->edgeint, 0,
255 );
}
//------------------------------------RenderData.SetEdgeColor() ---------
PyObject *RenderData_SetEdgeColor( BPy_RenderData * self, PyObject * args )
{
float red = 0.0f;
float green = 0.0f;
float blue = 0.0f;
if( !PyArg_ParseTuple( args, "fff", &red, &green, &blue ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected three floats" ) );
if( red < 0 || red > 1 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"value out of range 0.000 - 1.000 (red)" ) );
if( green < 0 || green > 1 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"value out of range 0.000 - 1.000 (green)" ) );
if( blue < 0 || blue > 1 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"value out of range 0.000 - 1.000 (blue)" ) );
self->renderContext->edgeR = red;
self->renderContext->edgeG = green;
self->renderContext->edgeB = blue;
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.GetEdgeColor() ---------
PyObject *RenderData_GetEdgeColor( BPy_RenderData * self )
{
char rgb[24];
sprintf( rgb, "[%.3f,%.3f,%.3f]\n", self->renderContext->edgeR,
self->renderContext->edgeG, self->renderContext->edgeB );
return PyString_FromString( rgb );
}
//------------------------------------RenderData.EdgeAntiShift() --------
PyObject *RenderData_EdgeAntiShift( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args,
&self->renderContext->
same_mat_redux, 0, 255 );
}
//------------------------------------RenderData.EnableOversampling() ---
PyObject *RenderData_EnableOversampling( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleInt( args, R_OSA,
&self->renderContext->mode );
}
//------------------------------------RenderData.SetOversamplingLevel() -
PyObject *RenderData_SetOversamplingLevel( BPy_RenderData * self,
PyObject * args )
{
int level;
if( !PyArg_ParseTuple( args, "i", &level ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected int" ) );
if( level != 5 && level != 8 && level != 11 && level != 16 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected 5,8,11, or 16" ) );
self->renderContext->osa = (short)level;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnableMotionBlur() -----
PyObject *RenderData_EnableMotionBlur( BPy_RenderData * self, PyObject * args )
{
return M_Render_BitToggleInt( args, R_MBLUR,
&self->renderContext->mode );
}
//------------------------------------RenderData.MotionBlurLevel() ------
PyObject *RenderData_MotionBlurLevel( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->blurfac,
0.01f, 5.0f );
}
//------------------------------------RenderData.PartsX() ---------------
PyObject *RenderData_PartsX( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args,
&self->renderContext->xparts, 1,
64 );
}
//------------------------------------RenderData.PartsY() ---------------
PyObject *RenderData_PartsY( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args,
&self->renderContext->yparts, 1,
64 );
}
//------------------------------------RenderData.EnableSky() ------------
PyObject *RenderData_EnableSky( BPy_RenderData * self )
{
self->renderContext->alphamode = R_ADDSKY;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnablePremultiply() ----
PyObject *RenderData_EnablePremultiply( BPy_RenderData * self )
{
self->renderContext->alphamode = R_ALPHAPREMUL;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnableKey() ------------
PyObject *RenderData_EnableKey( BPy_RenderData * self )
{
self->renderContext->alphamode = R_ALPHAKEY;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnableShadow() ---------
PyObject *RenderData_EnableShadow( BPy_RenderData * self, PyObject * args )
{
return M_Render_BitToggleInt( args, R_SHADOW,
&self->renderContext->mode );
}
//------------------------------------RenderData.EnvironmentMap() -------
PyObject *RenderData_EnableEnvironmentMap( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleInt( args, R_ENVMAP,
&self->renderContext->mode );
}
//------------------------------------RenderData.EnablePanorama() -------
PyObject *RenderData_EnablePanorama( BPy_RenderData * self, PyObject * args )
{
return M_Render_BitToggleInt( args, R_PANORAMA,
&self->renderContext->mode );
}
//------------------------------------RenderData.EnableRayTracing() -----
PyObject *RenderData_EnableRayTracing( BPy_RenderData * self, PyObject * args )
{
return M_Render_BitToggleInt( args, R_RAYTRACE,
&self->renderContext->mode );
}
//------------------------------------RenderData.EnableRadiosityRender()
PyObject *RenderData_EnableRadiosityRender( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleInt( args, R_RADIO,
&self->renderContext->mode );
}
//------------------------------------RenderData.SetRenderWinSize() -----
PyObject *RenderData_SetRenderWinSize( BPy_RenderData * self, PyObject * args )
{
int size;
if( !PyArg_ParseTuple( args, "i", &size ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected int" ) );
if( size != 25 && size != 50 && size != 75 && size != 100 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected 25, 50, 75, or 100" ) );
self->renderContext->size = (short)size;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnableFieldRendering() -
PyObject *RenderData_EnableFieldRendering( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleInt( args, R_FIELDS,
&self->renderContext->mode );
}
//------------------------------------RenderData.EnableOddFieldFirst() --
PyObject *RenderData_EnableOddFieldFirst( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleInt( args, R_ODDFIELD,
&self->renderContext->mode );
}
//------------------------------------RenderData.EnableFieldTimeDisable()
PyObject *RenderData_EnableFieldTimeDisable( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleInt( args, R_FIELDSTILL,
&self->renderContext->mode );
}
//------------------------------------RenderData.EnableGaussFilter() ----
PyObject *RenderData_EnableGaussFilter( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleInt( args, R_GAUSS,
&self->renderContext->mode );
}
//------------------------------------RenderData.EnableBorderRender() ---
PyObject *RenderData_EnableBorderRender( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleInt( args, R_BORDER,
&self->renderContext->mode );
}
//------------------------------------RenderData.SetBorder() ------------
PyObject *RenderData_SetBorder( BPy_RenderData * self, PyObject * args )
{
float xmin = 0.0f, ymin = 0.0f, xmax = 0.0f, ymax = 0.0f;
int status = 0;
PyObject *ob_args;
//left,botton | right,top coords - in that order
if( PyObject_Length( args ) == 4 ) {
status = PyArg_ParseTuple( args, "ffff", &xmin, &ymin, &xmax,
&ymax );
} else {
if( PyArg_ParseTuple( args, "O", &ob_args ) ) {
if( PyList_Check( ob_args ) )
status = PyArg_ParseTuple( args, "(ffff)",
&xmin, &ymin, &xmax,
&ymax );
else {
status = 0;
}
} else {
status = 0;
}
}
if( !status ) /* parsing args failed */
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected four floats" ) );
if( xmin > 1.0 || xmin < 0.0 || ymin > 1.0 || ymin < 0.0 ||
xmax > 1.0 || xmax < 0.0 || ymax > 1.0 || ymax < 0.0 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"all values must be between 0.0 and 1.0" ) );
self->renderContext->border.xmin = xmin;
self->renderContext->border.ymin = ymin;
self->renderContext->border.xmax = xmax;
self->renderContext->border.ymax = ymax;
EXPP_allqueue( REDRAWVIEWCAM, 1 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnableGammaCorrection()
PyObject *RenderData_EnableGammaCorrection( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleInt( args, R_GAMMA,
&self->renderContext->mode );
}
//------------------------------------RenderData.GaussFilterSize() ------
PyObject *RenderData_GaussFilterSize( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->gauss,
0.5f, 1.5f );
}
//------------------------------------RenderData.StartFrame() -----------
PyObject *RenderData_StartFrame( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args, &self->renderContext->sfra,
1, MAXFRAME );
}
//------------------------------------RenderData.CurrentFrame() ---------
PyObject *RenderData_CurrentFrame( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args, &self->renderContext->cfra,
1, MAXFRAME );
}
//------------------------------------RenderData.EndFrame() -------------
PyObject *RenderData_EndFrame( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args, &self->renderContext->efra,
1, MAXFRAME );
}
//------------------------------------RenderData.ImageSizeX() ----------
PyObject *RenderData_ImageSizeX( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args, &self->renderContext->xsch,
4, 10000 );
}
//------------------------------------RenderData.ImageSizeY() -----------
PyObject *RenderData_ImageSizeY( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args, &self->renderContext->ysch,
4, 10000 );
}
//------------------------------------RenderData.AspectRatioX() ---------
PyObject *RenderData_AspectRatioX( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args, &self->renderContext->xasp,
1, 200 );
}
//------------------------------------RenderData.AspectRatioY() ---------
PyObject *RenderData_AspectRatioY( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args, &self->renderContext->yasp,
1, 200 );
}
//------------------------------------RenderData.SetRenderer() ----------
PyObject *RenderData_SetRenderer( BPy_RenderData * self, PyObject * args )
{
int type;
if( !PyArg_ParseTuple( args, "i", &type ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected constant INTERN or YAFRAY" ) );
if( type == R_INTERN )
self->renderContext->renderer = R_INTERN;
else if( type == R_YAFRAY )
self->renderContext->renderer = R_YAFRAY;
else
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected INTERN or YAFRAY" ) );
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnableCropping() -------
PyObject *RenderData_EnableCropping( BPy_RenderData * self, PyObject * args )
{
return M_Render_BitToggleInt( args, R_MOVIECROP,
&self->renderContext->mode );
}
//------------------------------------RenderData.SetImageType() ---------
PyObject *RenderData_SetImageType( BPy_RenderData * self, PyObject * args )
{
int type;
if( !PyArg_ParseTuple( args, "i", &type ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected constant" ) );
if( type == R_AVIRAW )
self->renderContext->imtype = R_AVIRAW;
else if( type == R_AVIJPEG )
self->renderContext->imtype = R_AVIJPEG;
#ifdef _WIN32
else if( type == R_AVICODEC )
self->renderContext->imtype = R_AVICODEC;
#endif
else if( type == R_QUICKTIME && G.have_quicktime )
self->renderContext->imtype = R_QUICKTIME;
else if( type == R_TARGA )
self->renderContext->imtype = R_TARGA;
else if( type == R_RAWTGA )
self->renderContext->imtype = R_RAWTGA;
else if( type == R_RADHDR )
self->renderContext->imtype = R_RADHDR;
else if( type == R_PNG )
self->renderContext->imtype = R_PNG;
else if( type == R_BMP )
self->renderContext->imtype = R_BMP;
else if( type == R_JPEG90 )
self->renderContext->imtype = R_JPEG90;
else if( type == R_HAMX )
self->renderContext->imtype = R_HAMX;
else if( type == R_IRIS )
self->renderContext->imtype = R_IRIS;
else if( type == R_IRIZ )
self->renderContext->imtype = R_IRIZ;
else if( type == R_FTYPE )
self->renderContext->imtype = R_FTYPE;
else
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"unknown constant - see modules dict for help" ) );
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.Quality() --------------
PyObject *RenderData_Quality( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args,
&self->renderContext->quality,
10, 100 );
}
//------------------------------------RenderData.FramesPerSec() ---------
PyObject *RenderData_FramesPerSec( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeShort( args,
&self->renderContext->frs_sec, 1,
120 );
}
//------------------------------------RenderData.EnableGrayscale() ------
PyObject *RenderData_EnableGrayscale( BPy_RenderData * self )
{
self->renderContext->planes = R_PLANESBW;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnableRGBColor() -------
PyObject *RenderData_EnableRGBColor( BPy_RenderData * self )
{
self->renderContext->planes = R_PLANES24;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnableRGBAColor() ------
PyObject *RenderData_EnableRGBAColor( BPy_RenderData * self )
{
self->renderContext->planes = R_PLANES32;
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.SizePreset() -----------
PyObject *RenderData_SizePreset( BPy_RenderData * self, PyObject * args )
{
int type;
if( !PyArg_ParseTuple( args, "i", &type ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected constant" ) );
if( type == B_PR_PAL ) {
M_Render_DoSizePreset( self, 720, 576, 54, 51, 100,
self->renderContext->xparts,
self->renderContext->yparts, 25, 0.1f,
0.9f, 0.1f, 0.9f );
self->renderContext->mode &= ~R_PANORAMA;
BLI_init_rctf( &self->renderContext->safety, 0.1f, 0.9f, 0.1f,
0.9f );
} else if( type == B_PR_NTSC ) {
M_Render_DoSizePreset( self, 720, 480, 10, 11, 100, 1, 1,
30, 0.1f, 0.9f, 0.1f, 0.9f );
self->renderContext->mode &= ~R_PANORAMA;
BLI_init_rctf( &self->renderContext->safety, 0.1f, 0.9f, 0.1f,
0.9f );
} else if( type == B_PR_PRESET ) {
M_Render_DoSizePreset( self, 720, 576, 54, 51, 100, 1, 1,
self->renderContext->frs_sec, 0.1f, 0.9f,
0.1f, 0.9f );
self->renderContext->mode = R_OSA + R_SHADOW + R_FIELDS;
self->renderContext->imtype = R_TARGA;
BLI_init_rctf( &self->renderContext->safety, 0.1f, 0.9f, 0.1f,
0.9f );
} else if( type == B_PR_PRV ) {
M_Render_DoSizePreset( self, 640, 512, 1, 1, 50, 1, 1,
self->renderContext->frs_sec, 0.1f, 0.9f,
0.1f, 0.9f );
self->renderContext->mode &= ~R_PANORAMA;
BLI_init_rctf( &self->renderContext->safety, 0.1f, 0.9f, 0.1f,
0.9f );
} else if( type == B_PR_PC ) {
M_Render_DoSizePreset( self, 640, 480, 100, 100, 100, 1, 1,
self->renderContext->frs_sec, 0.0f, 1.0f,
0.0f, 1.0f );
self->renderContext->mode &= ~R_PANORAMA;
BLI_init_rctf( &self->renderContext->safety, 0.0f, 1.0f, 0.0f,
1.0f );
} else if( type == B_PR_PAL169 ) {
M_Render_DoSizePreset( self, 720, 576, 64, 45, 100, 1, 1,
25, 0.1f, 0.9f, 0.1f, 0.9f );
self->renderContext->mode &= ~R_PANORAMA;
BLI_init_rctf( &self->renderContext->safety, 0.1f, 0.9f, 0.1f,
0.9f );
} else if( type == B_PR_PANO ) {
M_Render_DoSizePreset( self, 36, 176, 115, 100, 100, 16, 1,
self->renderContext->frs_sec, 0.1f, 0.9f,
0.1f, 0.9f );
self->renderContext->mode |= R_PANORAMA;
BLI_init_rctf( &self->renderContext->safety, 0.1f, 0.9f, 0.1f,
0.9f );
} else if( type == B_PR_FULL ) {
M_Render_DoSizePreset( self, 1280, 1024, 1, 1, 100, 1, 1,
self->renderContext->frs_sec, 0.1f, 0.9f,
0.1f, 0.9f );
self->renderContext->mode &= ~R_PANORAMA;
BLI_init_rctf( &self->renderContext->safety, 0.1f, 0.9f, 0.1f,
0.9f );
} else
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"unknown constant - see modules dict for help" ) );
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnableUnifiedRenderer()
PyObject *RenderData_EnableUnifiedRenderer( BPy_RenderData * self,
PyObject * args )
{
return M_Render_BitToggleInt( args, R_UNIFIED,
&self->renderContext->mode );
}
//------------------------------------RenderData.SetYafrayGIQuality() ---
PyObject *RenderData_SetYafrayGIQuality( BPy_RenderData * self,
PyObject * args )
{
int type;
if( !PyArg_ParseTuple( args, "i", &type ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected constant" ) );
if( type == PY_NONE || type == PY_LOW ||
type == PY_MEDIUM || type == PY_HIGH ||
type == PY_HIGHER || type == PY_BEST ) {
self->renderContext->GIquality = (short)type;
} else
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"unknown constant - see modules dict for help" ) );
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.SetYafrayGIMethod() ----
PyObject *RenderData_SetYafrayGIMethod( BPy_RenderData * self,
PyObject * args )
{
int type;
if( !PyArg_ParseTuple( args, "i", &type ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected constant" ) );
if( type == PY_NONE || type == PY_SKYDOME || type == PY_FULL ) {
self->renderContext->GImethod = (short)type;
} else
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"unknown constant - see modules dict for help" ) );
EXPP_allqueue( REDRAWBUTSSCENE, 0 );
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.YafrayGIPower() --------
PyObject *RenderData_YafrayGIPower( BPy_RenderData * self, PyObject * args )
{
if( self->renderContext->GImethod > 0 ) {
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->
GIpower, 0.01f,
100.00f );
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'SKYDOME' or 'FULL'" ) );
}
//------------------------------------RenderData.YafrayGIDepth() --------
PyObject *RenderData_YafrayGIDepth( BPy_RenderData * self, PyObject * args )
{
if( self->renderContext->GImethod == 2 ) {
return M_Render_GetSetAttributeInt( args,
&self->renderContext->
GIdepth, 1, 8 );
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'FULL'" ) );
}
//------------------------------------RenderData.afrayGICDepth() --------
PyObject *RenderData_YafrayGICDepth( BPy_RenderData * self, PyObject * args )
{
if( self->renderContext->GImethod == 2 ) {
return M_Render_GetSetAttributeInt( args,
&self->renderContext->
GIcausdepth, 1, 8 );
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'FULL'" ) );
}
//------------------------------------RenderData.EnableYafrayGICache() --
PyObject *RenderData_EnableYafrayGICache( BPy_RenderData * self,
PyObject * args )
{
if( self->renderContext->GImethod == 2 ) {
return M_Render_BitToggleShort( args, 1,
&self->renderContext->
GIcache );
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'FULL'" ) );
}
//------------------------------------RenderData.EnableYafrayGIPhotons()
PyObject *RenderData_EnableYafrayGIPhotons( BPy_RenderData * self,
PyObject * args )
{
if( self->renderContext->GImethod == 2 ) {
return M_Render_BitToggleShort( args, 1,
&self->renderContext->
GIphotons );;
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'FULL'" ) );
}
//------------------------------------RenderData.YafrayGIPhotonCount() --
PyObject *RenderData_YafrayGIPhotonCount( BPy_RenderData * self,
PyObject * args )
{
if( self->renderContext->GImethod == 2
&& self->renderContext->GIphotons == 1 ) {
return M_Render_GetSetAttributeInt( args,
&self->renderContext->
GIphotoncount, 0,
10000000 );
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'FULL' and GIPhotons must be enabled\n" ) );
}
//------------------------------------RenderData.YafrayGIPhotonRadius() -
PyObject *RenderData_YafrayGIPhotonRadius( BPy_RenderData * self,
PyObject * args )
{
if( self->renderContext->GImethod == 2
&& self->renderContext->GIphotons == 1 ) {
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->
GIphotonradius, 0.00001f,
100.0f );
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'FULL' and GIPhotons must be enabled\n" ) );
}
//------------------------------------RenderData.YafrayGIPhotonMixCount()
PyObject *RenderData_YafrayGIPhotonMixCount( BPy_RenderData * self,
PyObject * args )
{
if( self->renderContext->GImethod == 2
&& self->renderContext->GIphotons == 1 ) {
return M_Render_GetSetAttributeInt( args,
&self->renderContext->
GImixphotons, 0, 1000 );
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'FULL' and GIPhotons must be enabled\n" ) );
}
//--------------------------RenderData.EnableYafrayGITunePhotons() ------
PyObject *RenderData_EnableYafrayGITunePhotons( BPy_RenderData * self,
PyObject * args )
{
if( self->renderContext->GImethod == 2
&& self->renderContext->GIphotons == 1 ) {
return M_Render_BitToggleShort( args, 1,
&self->renderContext->
GIdirect );;
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'FULL' and GIPhotons must be enabled" ) );
}
//------------------------------------RenderData.YafrayGIShadowQuality()
PyObject *RenderData_YafrayGIShadowQuality( BPy_RenderData * self,
PyObject * args )
{
if( self->renderContext->GImethod == 2
&& self->renderContext->GIcache == 1 ) {
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->
GIshadowquality, 0.01f,
1.0f );
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'FULL' and GICache must be enabled\n" ) );
}
//------------------------------------RenderData.YafrayGIPixelsPerSample()
PyObject *RenderData_YafrayGIPixelsPerSample( BPy_RenderData * self,
PyObject * args )
{
if( self->renderContext->GImethod == 2
&& self->renderContext->GIcache == 1 ) {
return M_Render_GetSetAttributeInt( args,
&self->renderContext->
GIpixelspersample, 1, 50 );
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'FULL' and GICache must be enabled\n" ) );
}
//------------------------------------RenderData.YafrayGIRefinement() ----
PyObject *RenderData_YafrayGIRefinement( BPy_RenderData * self,
PyObject * args )
{
if( self->renderContext->GImethod == 2
&& self->renderContext->GIcache == 1 ) {
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->
GIrefinement, 0.001f,
1.0f );
} else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"YafrayGIMethod must be set to 'FULL' and GICache must be enabled\n" ) );
}
//------------------------------------RenderData.YafrayRayBias() ---------
PyObject *RenderData_YafrayRayBias( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->YF_raybias,
0.0f, 10.0f );
}
//------------------------------------RenderData.YafrayRayDepth() --------
PyObject *RenderData_YafrayRayDepth( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeInt( args,
&self->renderContext->YF_raydepth,
1, 80 );
}
//------------------------------------RenderData.YafrayGamma() -----------
PyObject *RenderData_YafrayGamma( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->YF_gamma,
0.001f, 5.0f );
}
//------------------------------------RenderData.YafrayExposure() --------
PyObject *RenderData_YafrayExposure( BPy_RenderData * self, PyObject * args )
{
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->
YF_exposure, 0.0f, 10.0f );
}
//------------------------------------RenderData.YafrayProcessorCount() --
PyObject *RenderData_YafrayProcessorCount( BPy_RenderData * self,
PyObject * args )
{
return M_Render_GetSetAttributeInt( args,
&self->renderContext->YF_numprocs,
1, 8 );
}
//------------------------------------RenderData.EnableGameFrameStretch() -----------------------------------------------------------
PyObject *RenderData_EnableGameFrameStretch( BPy_RenderData * self )
{
self->scene->framing.type = SCE_GAMEFRAMING_SCALE;
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnableGameFrameExpose() -
PyObject *RenderData_EnableGameFrameExpose( BPy_RenderData * self )
{
self->scene->framing.type = SCE_GAMEFRAMING_EXTEND;
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.EnableGameFrameBars() ---
PyObject *RenderData_EnableGameFrameBars( BPy_RenderData * self )
{
self->scene->framing.type = SCE_GAMEFRAMING_BARS;
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.SetGameFrameColor() -----
PyObject *RenderData_SetGameFrameColor( BPy_RenderData * self,
PyObject * args )
{
float red = 0.0f;
float green = 0.0f;
float blue = 0.0f;
if( !PyArg_ParseTuple( args, "fff", &red, &green, &blue ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected three floats" ) );
if( red < 0 || red > 1 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"value out of range 0.000 - 1.000 (red)" ) );
if( green < 0 || green > 1 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"value out of range 0.000 - 1.000 (green)" ) );
if( blue < 0 || blue > 1 )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"value out of range 0.000 - 1.000 (blue)" ) );
self->scene->framing.col[0] = red;
self->scene->framing.col[1] = green;
self->scene->framing.col[2] = blue;
return EXPP_incr_ret( Py_None );
}
//------------------------------------RenderData.GetGameFrameColor() -----
PyObject *RenderData_GetGameFrameColor( BPy_RenderData * self )
{
char rgb[24];
sprintf( rgb, "[%.3f,%.3f,%.3f]\n", self->scene->framing.col[0],
self->scene->framing.col[1], self->scene->framing.col[2] );
return PyString_FromString( rgb );
}
//------------------------------------RenderData.GammaLevel() ------------
PyObject *RenderData_GammaLevel( BPy_RenderData * self, PyObject * args )
{
if( self->renderContext->mode & R_UNIFIED ) {
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->
gamma, 0.2f, 5.0f );
} else
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"Unified Render must be enabled" ) );
}
//------------------------------------RenderData.PostProcessAdd() --------
PyObject *RenderData_PostProcessAdd( BPy_RenderData * self, PyObject * args )
{
if( self->renderContext->mode & R_UNIFIED ) {
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->
postadd, -1.0f, 1.0f );
} else
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"Unified Render must be enabled" ) );
}
//------------------------------------RenderData.PostProcessMultiply() ---
PyObject *RenderData_PostProcessMultiply( BPy_RenderData * self,
PyObject * args )
{
if( self->renderContext->mode & R_UNIFIED ) {
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->
postmul, 0.01f, 4.0f );
} else
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"Unified Render must be enabled" ) );
}
//------------------------------------RenderData.PostProcessGamma() ------
PyObject *RenderData_PostProcessGamma( BPy_RenderData * self, PyObject * args )
{
if( self->renderContext->mode & R_UNIFIED ) {
return M_Render_GetSetAttributeFloat( args,
&self->renderContext->
postgamma, 0.2f, 2.0f );
} else
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"Unified Render must be enabled" ) );
}
//------------------------------------RenderData.SGIMaxsize() ------------
PyObject *RenderData_SGIMaxsize( BPy_RenderData * self, PyObject * args )
{
#ifdef __sgi
return M_Render_GetSetAttributeShort( args,
&self->renderContext->maximsize,
0, 500 );
#else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"SGI is not defined on this machine" ) );
#endif
}
//------------------------------------RenderData.EnableSGICosmo() --------
PyObject *RenderData_EnableSGICosmo( BPy_RenderData * self, PyObject * args )
{
#ifdef __sgi
return M_Render_BitToggleInt( args, R_COSMO,
&self->renderContext->mode );
#else
return ( EXPP_ReturnPyObjError( PyExc_StandardError,
"SGI is not defined on this machine" ) );
#endif
}
//------------------------------------RenderData.OldMapValue() -----------
PyObject *RenderData_OldMapValue( BPy_RenderData * self, PyObject * args )
{
PyObject *tmp = M_Render_GetSetAttributeShort(args,
&self->renderContext->framapto, 1, 900);
self->renderContext->framelen =
(float)self->renderContext->framapto / self->renderContext->images;
return tmp;
}
//------------------------------------RenderData.NewMapValue() -----------
PyObject *RenderData_NewMapValue( BPy_RenderData * self, PyObject * args )
{
PyObject *tmp = M_Render_GetSetAttributeShort(args,
&self->renderContext->images, 1, 900);
self->renderContext->framelen =
(float)self->renderContext->framapto / self->renderContext->images;
return tmp;
}
//------------------------------------RenderData.getTimeCode() -----------
PyObject *RenderData_getTimeCode( BPy_RenderData * self){
PyObject *ret = NULL;
char tc[12];
char h[3],m[3],s[3],f[3];
int hi,mi,si,fi,hold,fps,cfa;
fps = self->renderContext->frs_sec;
cfa = self->renderContext->cfra-1;
fi = cfa % fps;
hi = (cfa) / (fps*60*60);
hold = (cfa) % (fps*60*60);
mi = hold / (fps*60);
hold = hold % (fps*60);
si = hold / fps;
if(hi > 99){
ret = PyString_FromString("Time Greater than 99 Hours!");
}
else{
if(hi > 9)
sprintf(h,"%d",hi);
else
sprintf(h,"0%d",hi);
if(mi > 9)
sprintf(m,"%d",mi);
else
sprintf(m,"0%d",mi);
if(si > 9)
sprintf(s,"%d",si);
else
sprintf(s,"0%d",si);
if(fi > 9)
sprintf(f,"%d",fi);
else
sprintf(f,"0%d",fi);
sprintf(tc,"%s:%s:%s:%s",h,m,s,f);
ret = PyString_FromString(tc);
}
return ret;
}
View Git Blame Copy Permalink