* First commit merging 2.4-based sim_physics in to volume25 branch.
authorMatt Ebb <matt@mke3.net>
Thu, 13 Aug 2009 05:21:25 +0000 (05:21 +0000)
committerMatt Ebb <matt@mke3.net>
Thu, 13 Aug 2009 05:21:25 +0000 (05:21 +0000)
Integration is still very rough around the edges and WIP, but it works, and can render smoke (using new Smoke format in Voxel Data texture) --> http://vimeo.com/6030983

More to come, but this makes things much easier to work on for me :)

34 files changed:
1  2 
CMakeLists.txt
release/ui/buttons_material.py
release/ui/buttons_texture.py
source/blender/blenkernel/BKE_texture.h
source/blender/blenkernel/intern/material.c
source/blender/blenkernel/intern/texture.c
source/blender/blenlib/BLI_arithb.h
source/blender/blenlib/BLI_kdopbvh.h
source/blender/blenlib/intern/BLI_kdopbvh.c
source/blender/blenlib/intern/arithb.c
source/blender/blenlib/intern/voxel.c
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/writefile.c
source/blender/editors/preview/previewrender.c
source/blender/makesdna/DNA_material_types.h
source/blender/makesdna/DNA_texture_types.h
source/blender/makesrna/RNA_access.h
source/blender/makesrna/intern/rna_material.c
source/blender/makesrna/intern/rna_texture.c
source/blender/render/CMakeLists.txt
source/blender/render/extern/include/RE_shader_ext.h
source/blender/render/intern/include/render_types.h
source/blender/render/intern/include/shading.h
source/blender/render/intern/source/convertblender.c
source/blender/render/intern/source/occlusion.c
source/blender/render/intern/source/pointdensity.c
source/blender/render/intern/source/rayshade.c
source/blender/render/intern/source/raytrace.c
source/blender/render/intern/source/shadeinput.c
source/blender/render/intern/source/shadeoutput.c
source/blender/render/intern/source/texture.c
source/blender/render/intern/source/volume_precache.c
source/blender/render/intern/source/volumetric.c
source/blender/render/intern/source/voxeldata.c

diff --cc CMakeLists.txt
index aa1e26606ba1d4a0c03da3896b8026f752652419,0b7f3999e8264fb9546411c0f6b36490f881b4ba..edbb66290d360c8897ee4fb4767a147d47cdcc1e
@@@ -209,32 -213,32 +209,32 @@@ IF(WIN32
    ENDIF(CMAKE_CL_64)
  
    SET(PYTHON ${LIBDIR}/python)
 -  SET(PYTHON_VERSION 2.5)
 +  SET(PYTHON_VERSION 3.1)
    SET(PYTHON_INC "${PYTHON}/include/python${PYTHON_VERSION}")
    SET(PYTHON_BINARY python)
 -  SET(PYTHON_LIB python25)
 +  SET(PYTHON_LIB python31)
    SET(PYTHON_LIBPATH ${PYTHON}/lib)
  
 -  #SET(WITH_OPENAL ON)
 -  SET(OPENAL ${LIBDIR}/openal)
 -  SET(OPENAL_INC ${OPENAL}/include ${OPENAL}/include/AL)
 -  SET(OPENAL_LIB openal_static)
 -  SET(OPENAL_LIBPATH ${OPENAL}/lib)
 -
    IF(CMAKE_CL_64)
 -      SET(PNG_LIB libpng)
 +    SET(WITH_OPENAL OFF)
    ELSE(CMAKE_CL_64)
 -      SET(PNG_LIB libpng_st)
 +      #SET(WITH_OPENAL ON)
 +      SET(OPENAL ${LIBDIR}/openal)
 +      SET(OPENAL_INC ${OPENAL}/include)
 +      SET(OPENAL_LIB wrap_oal)
 +      SET(OPENAL_LIBPATH ${OPENAL}/lib)
    ENDIF(CMAKE_CL_64)
 -  SET(JPEG_LIB libjpeg)
  
 -  SET(ZLIB ${LIBDIR}/zlib)
 -  SET(ZLIB_INC ${ZLIB}/include)
    IF(CMAKE_CL_64)
 -      SET(ZLIB_LIB zlib)
 +      SET(PNG_LIBRARIES libpng)
    ELSE(CMAKE_CL_64)
 -      SET(ZLIB_LIB libz)
 +    SET(PNG_LIBRARIES libpng_st)
    ENDIF(CMAKE_CL_64)
-   SET(ZLIB_LIBRARIES zlib)
 +  SET(JPEG_LIBRARY libjpeg)
 +
 +  SET(ZLIB ${LIBDIR}/zlib)
 +  SET(ZLIB_INC ${ZLIB}/include)
++  SET(ZLIB_LIBRARIES libz)
    SET(ZLIB_LIBPATH ${ZLIB}/lib)
    
    SET(PTHREADS ${LIBDIR}/pthreads)
    SET(GETTEXT ${LIBDIR}/gettext)
    SET(GETTEXT_INC ${GETTEXT}/include)
    IF(CMAKE_CL_64)
--      SET(GETTEXT_LIB gettextlib)
++      SET(GETTEXT_LIB gettext)
    ELSE(CMAKE_CL_64)
        SET(GETTEXT_LIB gnu_gettext)
    ENDIF(CMAKE_CL_64)
index 16abc3c91f63ac0849b2f9cbb791abae6c9e6485,0000000000000000000000000000000000000000..4c919f813e230ba56711bc27a562c47cf49121c6
mode 100644,000000..100644
--- /dev/null
@@@ -1,539 -1,0 +1,600 @@@
-                       if mat.type in ('SURFACE', 'WIRE', 'VOLUME'):
 +      
 +import bpy
 +
 +class MaterialButtonsPanel(bpy.types.Panel):
 +      __space_type__ = "BUTTONS_WINDOW"
 +      __region_type__ = "WINDOW"
 +      __context__ = "material"
 +      # COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here
 +
 +      def poll(self, context):
 +              return (context.material) and (context.scene.render_data.engine in self.COMPAT_ENGINES)
 +
 +class MATERIAL_PT_preview(MaterialButtonsPanel):
 +      __label__ = "Preview"
 +      COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              
 +              layout.template_preview(mat)
 +              
 +class MATERIAL_PT_context_material(MaterialButtonsPanel):
 +      __show_header__ = False
 +      COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
 +
 +      def poll(self, context):
 +              # An exception, dont call the parent poll func because
 +              # this manages materials for all engine types
 +              
 +              return (context.object) and (context.scene.render_data.engine in self.COMPAT_ENGINES)
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              ob = context.object
 +              slot = context.material_slot
 +              space = context.space_data
 +
 +              if ob:
 +                      row = layout.row()
 +
 +                      row.template_list(ob, "materials", ob, "active_material_index", rows=2)
 +
 +                      col = row.column(align=True)
 +                      col.itemO("object.material_slot_add", icon="ICON_ZOOMIN", text="")
 +                      col.itemO("object.material_slot_remove", icon="ICON_ZOOMOUT", text="")
 +
 +                      if context.edit_object:
 +                              row = layout.row(align=True)
 +                              row.itemO("object.material_slot_assign", text="Assign")
 +                              row.itemO("object.material_slot_select", text="Select")
 +                              row.itemO("object.material_slot_deselect", text="Deselect")
 +
 +              split = layout.split(percentage=0.65)
 +
 +              if ob:
 +                      split.template_ID(ob, "active_material", new="material.new")
 +                      row = split.row()
 +                      if slot:
 +                              row.itemR(slot, "link", expand=True)
 +                      else:
 +                              row.itemL()
 +              elif mat:
 +                      split.template_ID(space, "pin_id")
 +                      split.itemS()
 +      
 +class MATERIAL_PT_material(MaterialButtonsPanel):
 +      __idname__= "MATERIAL_PT_material"
 +      __label__ = "Shading"
 +      COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              ob = context.object
 +              slot = context.material_slot
 +              space = context.space_data
 +
 +              if mat:
 +                      layout.itemR(mat, "type", expand=True)
 +
-               return mat and (mat.type != 'HALO') and (context.scene.render_data.engine in self.COMPAT_ENGINES)
++                      if mat.type in ['SURFACE', 'WIRE']:
 +                              split = layout.split()
 +      
 +                              col = split.column()
 +                              col.itemR(mat, "alpha", slider=True)
 +                              col.itemR(mat, "ambient", slider=True)
 +                              col.itemR(mat, "emit")
 +                              col.itemR(mat, "translucency", slider=True)
 +                              
 +                              col = split.column()
 +                              col.itemR(mat, "z_transparency")
 +                              col.itemR(mat, "shadeless")     
 +                              col.itemR(mat, "tangent_shading")
 +                              col.itemR(mat, "cubic", slider=True)
 +                              
 +                      elif mat.type == 'HALO':
 +                              layout.itemR(mat, "alpha", slider=True)
 +                      
 +class MATERIAL_PT_strand(MaterialButtonsPanel):
 +      __label__ = "Strand"
 +      __default_closed__ = True
 +      COMPAT_ENGINES = set(['BLENDER_RENDER'])
 +      
++      def poll(self, context):
++              return context.material.type in ['SURFACE', 'WIRE', 'HALO']
++      
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              tan = mat.strand
 +              
 +              split = layout.split()
 +              
 +              col = split.column()
 +              col.itemL(text="Size:")
 +              col.itemR(tan, "start_size", text="Root")
 +              col.itemR(tan, "end_size", text="Tip")
 +              col.itemR(tan, "min_size", text="Minimum")
 +              col.itemR(tan, "blender_units")
 +              sub = col.column()
 +              sub.active = (not mat.shadeless)
 +              sub.itemR(tan, "tangent_shading")
 +              
 +              col = split.column()
 +              col.itemR(tan, "shape")
 +              col.itemR(tan, "width_fade")
 +              col.itemR(tan, "uv_layer")
 +              sub = col.column()
 +              sub.active = (not mat.shadeless)
 +              sub.itemR(tan, "surface_diffuse")
 +              sub = col.column()
 +              sub.active = tan.surface_diffuse
 +              sub.itemR(tan, "blend_distance", text="Distance")
 +              
 +class MATERIAL_PT_physics(MaterialButtonsPanel):
 +      __label__ = "Physics"
 +      COMPAT_ENGINES = set(['BLENDER_GAME'])
 +      
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              phys = mat.physics
 +              
 +              split = layout.split()
 +              
 +              col = split.column()
 +              col.itemR(phys, "distance")
 +              col.itemR(phys, "friction")
 +              col.itemR(phys, "align_to_normal")
 +              
 +              col = split.column()
 +              col.itemR(phys, "force", slider=True)
 +              col.itemR(phys, "elasticity", slider=True)
 +              col.itemR(phys, "damp", slider=True)
 +              
 +class MATERIAL_PT_options(MaterialButtonsPanel):
 +      __label__ = "Options"
 +      COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
 +
++      def poll(self, context):
++              return (context.material.type in ['SURFACE', 'WIRE', 'HALO'])
++
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              
 +              split = layout.split()
 +              
 +              col = split.column()
 +              col.itemR(mat, "traceable")
 +              col.itemR(mat, "full_oversampling")
 +              col.itemR(mat, "sky")
 +              col.itemR(mat, "exclude_mist")
 +              col.itemR(mat, "invert_z")
 +              sub = col.column(align=True)
 +              sub.itemL(text="Light Group:")
 +              sub.itemR(mat, "light_group", text="")
 +              row = sub.row()
 +              row.active = mat.light_group
 +              row.itemR(mat, "light_group_exclusive", text="Exclusive")
 +
 +              col = split.column()
 +              col.itemR(mat, "face_texture")
 +              sub = col.column()
 +              sub.active = mat.face_texture
 +              sub.itemR(mat, "face_texture_alpha")
 +              col.itemS()
 +              col.itemR(mat, "vertex_color_paint")
 +              col.itemR(mat, "vertex_color_light")
 +              col.itemR(mat, "object_color")
 +
 +class MATERIAL_PT_shadows(MaterialButtonsPanel):
 +      __label__ = "Shadows"
 +      COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
++      
++      def poll(self, context):
++              return context.material.type in ['SURFACE', 'WIRE']
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              
 +              split = layout.split()
 +              
 +              col = split.column()
 +              col.itemR(mat, "shadows", text="Receive")
 +              col.itemR(mat, "transparent_shadows", text="Receive Transparent")
 +              col.itemR(mat, "only_shadow", text="Shadows Only")
 +              col.itemR(mat, "cast_shadows_only", text="Cast Only")
 +              col.itemR(mat, "shadow_casting_alpha", text="Casting Alpha", slider=True)
 +              
 +              col = split.column()
 +              col.itemR(mat, "cast_buffer_shadows")
 +              sub = col.column()
 +              sub.active = mat.cast_buffer_shadows
 +              sub.itemR(mat, "shadow_buffer_bias", text="Buffer Bias")
 +              col.itemR(mat, "ray_shadow_bias", text="Auto Ray Bias")
 +              sub = col.column()
 +              sub.active = (not mat.ray_shadow_bias)
 +              sub.itemR(mat, "shadow_ray_bias", text="Ray Bias")
 +              
 +
 +class MATERIAL_PT_diffuse(MaterialButtonsPanel):
 +      __label__ = "Diffuse"
 +      COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
 +
 +      def poll(self, context):
 +              mat = context.material
-               return mat and (mat.type != 'HALO') and (context.scene.render_data.engine in self.COMPAT_ENGINES)
++              return mat and (mat.type in ['SURFACE', 'WIRE']) and (context.scene.render_data.engine in self.COMPAT_ENGINES)
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material  
 +              
 +              split = layout.split()
 +              
 +              col = split.column()
 +              col.itemR(mat, "diffuse_color", text="")
 +              sub = col.column()
 +              sub.active = (not mat.shadeless)
 +              sub.itemR(mat, "diffuse_reflection", text="Intensity", slider=True)
 +              
 +              col = split.column()
 +              col.active = (not mat.shadeless)
 +              col.itemR(mat, "diffuse_shader", text="")
 +              col.itemR(mat, "use_diffuse_ramp", text="Ramp")
 +              
 +              col = layout.column()
 +              col.active = (not mat.shadeless)
 +              if mat.diffuse_shader == 'OREN_NAYAR':
 +                      col.itemR(mat, "roughness")
 +              elif mat.diffuse_shader == 'MINNAERT':
 +                      col.itemR(mat, "darkness")
 +              elif mat.diffuse_shader == 'TOON':
 +                      row = col.row()
 +                      row.itemR(mat, "diffuse_toon_size", text="Size")
 +                      row.itemR(mat, "diffuse_toon_smooth", text="Smooth", slider=True)
 +              elif mat.diffuse_shader == 'FRESNEL':
 +                      row = col.row()
 +                      row.itemR(mat, "diffuse_fresnel", text="Fresnel")
 +                      row.itemR(mat, "diffuse_fresnel_factor", text="Factor")
 +                      
 +              if mat.use_diffuse_ramp:
 +                      layout.itemS()
 +                      layout.template_color_ramp(mat.diffuse_ramp, expand=True)
 +                      layout.itemS()
 +                      row = layout.row()
 +                      split = row.split(percentage=0.3)
 +                      split.itemL(text="Input:")
 +                      split.itemR(mat, "diffuse_ramp_input", text="")
 +                      split = row.split(percentage=0.3)
 +                      split.itemL(text="Blend:")
 +                      split.itemR(mat, "diffuse_ramp_blend", text="")
 +                      
 +              
 +class MATERIAL_PT_specular(MaterialButtonsPanel):
 +      __label__ = "Specular"
 +      COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME'])
 +
 +      def poll(self, context):
 +              mat = context.material
-               return mat and (mat.type in ('SURFACE', 'WIRE')) and (context.scene.render_data.engine in self.COMPAT_ENGINES)
++              return mat and (mat.type in ['SURFACE', 'WIRE']) and (context.scene.render_data.engine in self.COMPAT_ENGINES)
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              
 +              layout.active = (not mat.shadeless)
 +              
 +              split = layout.split()
 +              
 +              col = split.column()
 +              col.itemR(mat, "specular_color", text="")
 +              col.itemR(mat, "specular_reflection", text="Intensity", slider=True)
 +
 +              col = split.column()
 +              col.itemR(mat, "specular_shader", text="")
 +              col.itemR(mat, "use_specular_ramp", text="Ramp")
 +
 +              col = layout.column()
 +              if mat.specular_shader in ('COOKTORR', 'PHONG'):
 +                      col.itemR(mat, "specular_hardness", text="Hardness")
 +              elif mat.specular_shader == 'BLINN':
 +                      row = col.row()
 +                      row.itemR(mat, "specular_hardness", text="Hardness")
 +                      row.itemR(mat, "specular_ior", text="IOR")
 +              elif mat.specular_shader == 'WARDISO':
 +                      col.itemR(mat, "specular_slope", text="Slope")
 +              elif mat.specular_shader == 'TOON':
 +                      row = col.row()
 +                      row.itemR(mat, "specular_toon_size", text="Size")
 +                      row.itemR(mat, "specular_toon_smooth", text="Smooth", slider=True)
 +              
 +              if mat.use_specular_ramp:
 +                      layout.itemS()
 +                      layout.template_color_ramp(mat.specular_ramp, expand=True)
 +                      layout.itemS()
 +                      row = layout.row()
 +                      split = row.split(percentage=0.3)
 +                      split.itemL(text="Input:")
 +                      split.itemR(mat, "specular_ramp_input", text="")
 +                      split = row.split(percentage=0.3)
 +                      split.itemL(text="Blend:")
 +                      split.itemR(mat, "specular_ramp_blend", text="")
 +              
 +class MATERIAL_PT_sss(MaterialButtonsPanel):
 +      __label__ = "Subsurface Scattering"
 +      __default_closed__ = True
 +      COMPAT_ENGINES = set(['BLENDER_RENDER'])
 +      
 +      def poll(self, context):
 +              mat = context.material
-               return mat and (mat.type in 'SURFACE', 'WIRE') and (context.scene.render_data.engine in self.COMPAT_ENGINES)
++              return mat and (mat.type in ['SURFACE', 'WIRE']) and (context.scene.render_data.engine in self.COMPAT_ENGINES)
 +
 +      def draw_header(self, context):
 +              layout = self.layout
 +              sss = context.material.subsurface_scattering
 +
 +              layout.itemR(sss, "enabled", text="")
 +      
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              sss = context.material.subsurface_scattering
 +
 +              layout.active = sss.enabled     
 +              
 +              split = layout.split()
 +              split.active = (not mat.shadeless)
 +              
 +              col = split.column(align=True)
 +              col.itemR(sss, "color", text="")
 +              col.itemL(text="Blend:")
 +              col.itemR(sss, "color_factor", text="Color", slider=True)
 +              col.itemR(sss, "texture_factor", text="Texture", slider=True)
 +              col.itemL(text="Scattering Weight:")
 +              col.itemR(sss, "front")
 +              col.itemR(sss, "back")
 +              
 +              col = split.column()
 +              sub = col.column(align=True)
 +              sub.itemR(sss, "ior")
 +              sub.itemR(sss, "scale")
 +              col.itemR(sss, "radius", text="RGB Radius")
 +              col.itemR(sss, "error_tolerance")
 +
 +class MATERIAL_PT_raymir(MaterialButtonsPanel):
 +      __label__ = "Ray Mirror"
 +      __default_closed__ = True
 +      COMPAT_ENGINES = set(['BLENDER_RENDER'])
 +      
 +      def poll(self, context):
 +              mat = context.material
-               return mat and (mat.type in 'SURFACE', 'WIRE') and (context.scene.render_data.engine in self.COMPAT_ENGINES)
++              return mat and (mat.type in ['SURFACE', 'WIRE']) and (context.scene.render_data.engine in self.COMPAT_ENGINES)
 +      
 +      def draw_header(self, context):
 +              layout = self.layout
 +              
 +              raym = context.material.raytrace_mirror
 +
 +              layout.itemR(raym, "enabled", text="")
 +      
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              raym = context.material.raytrace_mirror
 +              
 +              layout.active = raym.enabled
 +              
 +              split = layout.split()
 +              
 +              col = split.column()
 +              col.itemR(raym, "reflect", text="Reflectivity", slider=True)
 +              col.itemR(mat, "mirror_color", text="")
 +              col.itemL(text="Fresnel:")
 +              col.itemR(raym, "fresnel", text="Amount")
 +              sub = col.column()
 +              sub.active = raym.fresnel > 0
 +              sub.itemR(raym, "fresnel_fac", text="Blend", slider=True)
 +              col.itemS()
 +              col.itemS()
 +              sub = col.split(percentage=0.4)
 +              sub.itemL(text="Fade To:")
 +              sub.itemR(raym, "fade_to", text="")
 +              
 +              col = split.column()
 +              col.itemR(raym, "depth")
 +              col.itemR(raym, "distance", text="Max Dist")
 +              col.itemL(text="Gloss:")
 +              col.itemR(raym, "gloss", text="Amount", slider=True)
 +              sub = col.column()
 +              sub.active = raym.gloss < 1
 +              sub.itemR(raym, "gloss_threshold", slider=True, text="Threshold")
 +              sub.itemR(raym, "gloss_samples", text="Samples")
 +              sub.itemR(raym, "gloss_anisotropic", slider=True, text="Anisotropic")
 +              
 +              
 +class MATERIAL_PT_raytransp(MaterialButtonsPanel):
 +      __label__= "Ray Transparency"
 +      __default_closed__ = True
 +      COMPAT_ENGINES = set(['BLENDER_RENDER'])
 +              
 +      def poll(self, context):
 +              mat = context.material
++              return mat and (mat.type in ['SURFACE', 'WIRE']) and (context.scene.render_data.engine in self.COMPAT_ENGINES)
 +
 +      def draw_header(self, context):
 +              layout = self.layout
 +              
 +              rayt = context.material.raytrace_transparency
 +
 +              layout.itemR(rayt, "enabled", text="")
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              rayt = context.material.raytrace_transparency
 +              
 +              layout.active = rayt.enabled and (not mat.shadeless)
 +              
 +              split = layout.split()
 +              
 +              col = split.column()
 +              col.itemR(rayt, "ior")
 +              col.itemR(rayt, "falloff")
 +              col.itemR(rayt, "limit")
 +              
 +              col = split.column()
 +              col.itemR(rayt, "depth")
 +              col.itemR(rayt, "filter", slider=True)
 +              col.itemR(rayt, "specular_opacity", slider=True, text="Spec Opacity")
 +              
 +              split = layout.split()
 +              
 +              col = split.column()
 +              col.itemL(text="Fresnel:")
 +              col.itemR(rayt, "fresnel", text="Amount")
 +              sub = col.column()
 +              sub.active = rayt.fresnel > 0
 +              sub.itemR(rayt, "fresnel_fac", text="Blend", slider=True)
 +              
 +              col = split.column()
 +              col.itemL(text="Gloss:")
 +              col.itemR(rayt, "gloss", text="Amount", slider=True)
 +              sub = col.column()
 +              sub.active = rayt.gloss < 1
 +              sub.itemR(rayt, "gloss_threshold", slider=True, text="Threshold")
 +              sub.itemR(rayt, "gloss_samples", text="Samples")
++
++class MATERIAL_PT_volume(MaterialButtonsPanel):
++      __label__ = "Volume"
++      __default_closed__ = False
++      COMPAT_ENGINES = set(['BLENDER_RENDER'])
++      
++      def poll(self, context):
++              return (context.material.type == 'VOLUME') and (context.scene.render_data.engine in self.COMPAT_ENGINES)
++      
++      def draw(self, context):
++              layout = self.layout
 +              
++              mat = context.material
++              vol = context.material.volume
++              
++              split = layout.split()
++              
++              col = split.column()
++              col.itemR(vol, "step_calculation")
++              col.itemR(vol, "step_size")
++              col.itemR(vol, "shading_step_size")
++              
++              col.itemR(mat, "alpha", text="Density", slider=True)
++              
++              col.itemR(vol, "scattering_mode")
++              if vol.scattering_mode == 'SINGLE':
++                      col.itemR(vol, "light_cache")
++                      sub = col.column()
++                      sub.active = vol.light_cache
++                      col.itemR(vol, "cache_resolution")
++              elif vol.scattering_mode in ['MULTIPLE', 'SINGLE_PLUS_MULTIPLE']:
++                      col.itemR(vol, "cache_resolution")
++                      col.itemR(vol, "ms_diffusion")
++                      col.itemR(vol, "ms_spread")
++                      col.itemR(vol, "ms_intensity")
++                      
++              col.itemR(vol, "density_scale")
++              col.itemR(vol, "depth_cutoff")
++              
++              col = split.column()
++              col.itemR(vol, "absorption")
++              col.itemR(vol, "absorption_color")
++              col.itemR(vol, "scattering")
++              
++              col.itemR(mat, "emit")
++              col.itemR(mat, "diffuse_color")
++              
++              col.itemR(vol, "phase_function")
++              col.itemR(vol, "asymmetry")
++              
++
++
 +class MATERIAL_PT_halo(MaterialButtonsPanel):
 +      __label__= "Halo"
 +      COMPAT_ENGINES = set(['BLENDER_RENDER'])
 +      
 +      def poll(self, context):
 +              mat = context.material
 +              return mat and (mat.type == 'HALO') and (context.scene.render_data.engine in self.COMPAT_ENGINES)
 +      
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              mat = context.material
 +              halo = mat.halo
 +
 +              split = layout.split()
 +              
 +              col = split.column()
 +              col.itemR(mat, "diffuse_color", text="")
 +              col.itemR(halo, "size")
 +              col.itemR(halo, "hardness")
 +              col.itemR(halo, "add", slider=True)
 +              col.itemL(text="Options:")
 +              col.itemR(halo, "use_texture", text="Texture")
 +              col.itemR(halo, "use_vertex_normal", text="Vertex Normal")
 +              col.itemR(halo, "xalpha")
 +              col.itemR(halo, "shaded")
 +              col.itemR(halo, "soft")
 +
 +              col = split.column()
 +              col.itemR(halo, "ring")
 +              sub = col.column()
 +              sub.active = halo.ring
 +              sub.itemR(halo, "rings")
 +              sub.itemR(mat, "mirror_color", text="")
 +              col.itemR(halo, "lines")
 +              sub = col.column()
 +              sub.active = halo.lines
 +              sub.itemR(halo, "line_number", text="Lines")
 +              sub.itemR(mat, "specular_color", text="")
 +              col.itemR(halo, "star")
 +              sub = col.column()
 +              sub.active = halo.star
 +              sub.itemR(halo, "star_tips")
 +              col.itemR(halo, "flare_mode")
 +              sub = col.column()
 +              sub.active = halo.flare_mode
 +              sub.itemR(halo, "flare_size", text="Size")
 +              sub.itemR(halo, "flare_subsize", text="Subsize")
 +              sub.itemR(halo, "flare_boost", text="Boost")
 +              sub.itemR(halo, "flare_seed", text="Seed")
 +              sub.itemR(halo, "flares_sub", text="Sub")
 +
 +bpy.types.register(MATERIAL_PT_context_material)
 +bpy.types.register(MATERIAL_PT_preview)
 +bpy.types.register(MATERIAL_PT_material)
 +bpy.types.register(MATERIAL_PT_diffuse)
 +bpy.types.register(MATERIAL_PT_specular)
 +bpy.types.register(MATERIAL_PT_raymir)
 +bpy.types.register(MATERIAL_PT_raytransp)
 +bpy.types.register(MATERIAL_PT_sss)
++bpy.types.register(MATERIAL_PT_volume)
 +bpy.types.register(MATERIAL_PT_halo)
 +bpy.types.register(MATERIAL_PT_physics)
 +bpy.types.register(MATERIAL_PT_strand)
 +bpy.types.register(MATERIAL_PT_options)
 +bpy.types.register(MATERIAL_PT_shadows)
index f3d5d96cc28d0e90f79932db8c99b0d369e3c941,0000000000000000000000000000000000000000..afc4825b15fc72dd2f48914eb86dfc5c9099f0c8
mode 100644,000000..100644
--- /dev/null
@@@ -1,632 -1,0 +1,680 @@@
++      
 +import bpy
 +
 +class TextureButtonsPanel(bpy.types.Panel):
 +      __space_type__ = "BUTTONS_WINDOW"
 +      __region_type__ = "WINDOW"
 +      __context__ = "texture"
 +      
 +      def poll(self, context):
 +              return (context.texture and context.texture.type != 'NONE')
 +              
 +class TEXTURE_PT_preview(TextureButtonsPanel):
 +      __label__ = "Preview"
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +              ma = context.material
 +              la = context.lamp
 +              wo = context.world
 +              br = context.brush
 +              
 +              if ma:
 +                      layout.template_preview(tex, parent=ma)
 +              elif la:
 +                      layout.template_preview(tex, parent=la)
 +              elif wo:
 +                      layout.template_preview(tex, parent=wo)
 +              elif br:
 +                      layout.template_preview(tex, parent=br)
 +              else:
 +                      layout.template_preview(tex)
 +
 +class TEXTURE_PT_context_texture(TextureButtonsPanel):
 +      __show_header__ = False
 +
 +      def poll(self, context):
 +              return (context.material or context.world or context.lamp or context.brush or context.texture)
 +
 +      def draw(self, context):
 +              layout = self.layout
 +
 +              tex = context.texture
 +              
 +              id = context.material
 +              if not id: id = context.lamp
 +              if not id: id = context.world
 +              if not id: id = context.brush
 +              
 +              space = context.space_data
 +
 +              if id:
 +                      row = layout.row()
 +                      row.template_list(id, "textures", id, "active_texture_index", rows=2)
 +                      
 +              split = layout.split(percentage=0.65)
 +
 +              if id:
 +                      split.template_ID(id, "active_texture", new="texture.new")
 +              elif tex:
 +                      split.template_ID(space, "pin_id")
 +
 +              if (not space.pin_id) and (     context.sculpt_object or \
 +                                                                      context.vertex_paint_object or \
 +                                                                      context.weight_paint_object or \
 +                                                                      context.texture_paint_object \
 +                                                                      ):
 +                      split.itemR(space, "brush_texture", text="Brush", toggle=True)
 +              
 +              layout.itemS()
 +
 +              if tex:
 +                      split = layout.split(percentage=0.2)
 +              
 +                      split.itemL(text="Type:")
 +                      split.itemR(tex, "type", text="")
 +
 +class TEXTURE_PT_mapping(TextureButtonsPanel):
 +      __label__ = "Mapping"
 +      
 +      def poll(self, context):
 +              return (context.texture_slot and context.texture and context.texture.type != 'NONE')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              ma = context.material
 +              la = context.lamp
 +              wo = context.world
 +              br = context.brush
 +              tex = context.texture_slot
 +              textype = context.texture
 +
 +              if not br:
 +                      split = layout.split(percentage=0.3)
 +                      col = split.column()
 +                      col.itemL(text="Coordinates:")
 +                      col = split.column()
 +                      col.itemR(tex, "texture_coordinates", text="")
 +
 +                      if tex.texture_coordinates == 'ORCO':
 +                              """
 +                              ob = context.object
 +                              if ob and ob.type == 'MESH':
 +                                      split = layout.split(percentage=0.3)
 +                                      split.itemL(text="Mesh:")
 +                                      split.itemR(ob.data, "texco_mesh", text="")
 +                              """
 +                      elif tex.texture_coordinates == 'UV':
 +                              split = layout.split(percentage=0.3)
 +                              split.itemL(text="Layer:")
 +                              split.itemR(tex, "uv_layer", text="")
 +                      elif tex.texture_coordinates == 'OBJECT':
 +                              split = layout.split(percentage=0.3)
 +                              split.itemL(text="Object:")
 +                              split.itemR(tex, "object", text="")
 +                      
 +              if ma:
 +                      split = layout.split(percentage=0.3)
 +                      split.itemL(text="Projection:")
 +                      split.itemR(tex, "mapping", text="")
 +
 +                      split = layout.split()
 +                      
 +                      col = split.column()
 +                      if tex.texture_coordinates in ('ORCO', 'UV'):
 +                              col.itemR(tex, "from_dupli")
 +                      elif tex.texture_coordinates == 'OBJECT':
 +                              col.itemR(tex, "from_original")
 +                      else:
 +                              col.itemL()
 +                      
 +                      col = split.column()
 +                      row = col.row()
 +                      row.itemR(tex, "x_mapping", text="")
 +                      row.itemR(tex, "y_mapping", text="")
 +                      row.itemR(tex, "z_mapping", text="")
 +
 +              row = layout.row()
 +              row.column().itemR(tex, "offset")
 +              row.column().itemR(tex, "size")
 +
 +class TEXTURE_PT_influence(TextureButtonsPanel):
 +      __label__ = "Influence"
 +      
 +      def poll(self, context):
 +              return (context.texture_slot and context.texture and context.texture.type != 'NONE' and (not context.brush))
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              ma = context.material
 +              la = context.lamp
 +              wo = context.world
 +              br = context.brush
 +              textype = context.texture
 +              tex = context.texture_slot
 +
 +              def factor_but(layout, active, toggle, factor, name):
 +                      row = layout.row(align=True)
 +                      row.itemR(tex, toggle, text="")
 +                      sub = row.row()
 +                      sub.active = active
 +                      sub.itemR(tex, factor, text=name, slider=True)
 +              
 +              if ma:
 +                      split = layout.split()
 +                      
 +                      col = split.column()
 +                      col.itemL(text="Diffuse:")
 +                      factor_but(col, tex.map_diffuse, "map_diffuse", "diffuse_factor", "Intensity")
 +                      factor_but(col, tex.map_colordiff, "map_colordiff", "colordiff_factor", "Color")
 +                      factor_but(col, tex.map_alpha, "map_alpha", "alpha_factor", "Alpha")
 +                      factor_but(col, tex.map_translucency, "map_translucency", "translucency_factor", "Translucency")
 +
 +                      col.itemL(text="Specular:")
 +                      factor_but(col, tex.map_specular, "map_specular", "specular_factor", "Intensity")
 +                      factor_but(col, tex.map_colorspec, "map_colorspec", "colorspec_factor", "Color")
 +                      factor_but(col, tex.map_hardness, "map_hardness", "hardness_factor", "Hardness")
 +
 +                      col = split.column()
 +                      col.itemL(text="Shading:")
 +                      factor_but(col, tex.map_ambient, "map_ambient", "ambient_factor", "Ambient")
 +                      factor_but(col, tex.map_emit, "map_emit", "emit_factor", "Emit")
 +                      factor_but(col, tex.map_mirror, "map_mirror", "mirror_factor", "Mirror")
 +                      factor_but(col, tex.map_raymir, "map_raymir", "raymir_factor", "Ray Mirror")
 +
 +                      col.itemL(text="Geometry:")
 +                      factor_but(col, tex.map_normal, "map_normal", "normal_factor", "Normal")
 +                      factor_but(col, tex.map_warp, "map_warp", "warp_factor", "Warp")
 +                      factor_but(col, tex.map_displacement, "map_displacement", "displacement_factor", "Displace")
 +
 +                      #sub = col.column()
 +                      #sub.active = tex.map_translucency or tex.map_emit or tex.map_alpha or tex.map_raymir or tex.map_hardness or tex.map_ambient or tex.map_specularity or tex.map_reflection or tex.map_mirror
 +                      #sub.itemR(tex, "default_value", text="Amount", slider=True)
 +              elif la:
 +                      row = layout.row()
 +                      factor_but(row, tex.map_color, "map_color", "color_factor", "Color")
 +                      factor_but(row, tex.map_shadow, "map_shadow", "shadow_factor", "Shadow")
 +              elif wo:
 +                      split = layout.split()
 +                      
 +                      col = split.column()
 +                      factor_but(col, tex.map_blend, "map_blend", "blend_factor", "Blend")
 +                      factor_but(col, tex.map_horizon, "map_horizon", "horizon_factor", "Horizon")
 +
 +                      col = split.column()
 +                      factor_but(col, tex.map_zenith_up, "map_zenith_up", "zenith_up_factor", "Zenith Up")
 +                      factor_but(col, tex.map_zenith_down, "map_zenith_down", "zenith_down_factor", "Zenith Down")
 +
 +              layout.itemS()
 +              
 +              split = layout.split()
 +
 +              col = split.column()
 +              col.itemR(tex, "blend_type", text="Blend")
 +              col.itemR(tex, "rgb_to_intensity")
 +              sub = col.column()
 +              sub.active = tex.rgb_to_intensity
 +              sub.itemR(tex, "color", text="")
 +
 +              col = split.column()
 +              col.itemR(tex, "negate", text="Negative")
 +              col.itemR(tex, "stencil")
 +              if ma or wo:
 +                      col.itemR(tex, "default_value", text="DVar", slider=True)
 +
 +class TEXTURE_PT_colors(TextureButtonsPanel):
 +      __label__ = "Colors"
 +      __default_closed__ = True
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +
 +              layout.itemR(tex, "use_color_ramp", text="Ramp")
 +              if tex.use_color_ramp:
 +                      layout.template_color_ramp(tex.color_ramp, expand=True)
 +
 +              split = layout.split()
 +              
 +              split.itemR(tex, "rgb_factor", text="Multiply RGB")
 +
 +              col = split.column()
 +              col.itemL(text="Adjust:")
 +              col.itemR(tex, "brightness")
 +              col.itemR(tex, "contrast")
 +              
 +# Texture Type Panels #
 +
 +class TEXTURE_PT_clouds(TextureButtonsPanel):
 +      __label__ = "Clouds"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'CLOUDS')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +              
 +              layout.itemR(tex, "stype", expand=True)
 +              layout.itemL(text="Noise:")
 +              layout.itemR(tex, "noise_type", text="Type", expand=True)
 +              layout.itemR(tex, "noise_basis", text="Basis")
 +              
 +              flow = layout.column_flow()
 +              flow.itemR(tex, "noise_size", text="Size")
 +              flow.itemR(tex, "noise_depth", text="Depth")
 +              flow.itemR(tex, "nabla", text="Nabla")
 +
 +class TEXTURE_PT_wood(TextureButtonsPanel):
 +      __label__ = "Wood"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'WOOD')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +              
 +              layout.itemR(tex, "noisebasis2", expand=True)
 +              layout.itemR(tex, "stype", expand=True)
 +              
 +              col = layout.column()
 +              col.active = tex.stype in ('RINGNOISE', 'BANDNOISE')
 +              col.itemL(text="Noise:")
 +              col.row().itemR(tex, "noise_type", text="Type", expand=True)
 +              col.itemR(tex, "noise_basis", text="Basis")
 +              
 +              flow = layout.column_flow()
 +              flow.active = tex.stype in ('RINGNOISE', 'BANDNOISE')
 +              flow.itemR(tex, "noise_size", text="Size")
 +              flow.itemR(tex, "turbulence")
 +              flow.itemR(tex, "nabla")
 +              
 +class TEXTURE_PT_marble(TextureButtonsPanel):
 +      __label__ = "Marble"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'MARBLE')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +              
 +              layout.itemR(tex, "stype", expand=True)
 +              layout.itemR(tex, "noisebasis2", expand=True)
 +              layout.itemL(text="Noise:")
 +              layout.itemR(tex, "noise_type", text="Type", expand=True)
 +              layout.itemR(tex, "noise_basis", text="Basis")
 +              
 +              flow = layout.column_flow()     
 +              flow.itemR(tex, "noise_size", text="Size")
 +              flow.itemR(tex, "noise_depth", text="Depth")
 +              flow.itemR(tex, "turbulence")
 +              flow.itemR(tex, "nabla")
 +
 +class TEXTURE_PT_magic(TextureButtonsPanel):
 +      __label__ = "Magic"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'MAGIC')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +                      
 +              row = layout.row()
 +              row.itemR(tex, "noise_depth", text="Depth")
 +              row.itemR(tex, "turbulence")
 +
 +class TEXTURE_PT_blend(TextureButtonsPanel):
 +      __label__ = "Blend"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'BLEND')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +
 +              layout.itemR(tex, "progression")
 +              layout.itemR(tex, "flip_axis")
 +                      
 +class TEXTURE_PT_stucci(TextureButtonsPanel):
 +      __label__ = "Stucci"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'STUCCI')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +              
 +              layout.itemR(tex, "stype", expand=True)
 +              layout.itemL(text="Noise:")
 +              layout.itemR(tex, "noise_type", text="Type", expand=True)
 +              layout.itemR(tex, "noise_basis", text="Basis")
 +              
 +              row = layout.row()
 +              row.itemR(tex, "noise_size", text="Size")
 +              row.itemR(tex, "turbulence")
 +              
 +class TEXTURE_PT_image(TextureButtonsPanel):
 +      __label__ = "Image"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'IMAGE')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +
 +              layout.template_texture_image(tex)
 +
 +class TEXTURE_PT_image_sampling(TextureButtonsPanel):
 +      __label__ = "Image Sampling"
 +      __default_closed__ = True
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'IMAGE')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +              slot = context.texture_slot
 +              
 +              split = layout.split()
 +              
 +              """
 +              col = split.column()            
 +              col.itemR(tex, "flip_axis")
 +              col.itemR(tex, "normal_map")
 +              if slot:
 +                      row = col.row()
 +                      row.active = tex.normal_map
 +                      row.itemR(slot, "normal_map_space", text="")
 +              """
 +
 +              col = split.column()
 +              col.itemL(text="Alpha:")
 +              col.itemR(tex, "use_alpha", text="Use")
 +              col.itemR(tex, "calculate_alpha", text="Calculate")
 +              col.itemR(tex, "invert_alpha", text="Invert")
 +
 +              col.itemL(text="Flip:")
 +              col.itemR(tex, "flip_axis", text="X/Y Axis")
 +
 +              col = split.column() 
 +              col.itemL(text="Filter:")
 +              col.itemR(tex, "filter", text="")
 +              col.itemR(tex, "mipmap")
 +              
 +              row = col.row()
 +              row.active = tex.mipmap
 +              row.itemR(tex, "mipmap_gauss", text="Gauss")
 +              
 +              col.itemR(tex, "interpolation")
 +              if tex.mipmap and tex.filter != 'DEFAULT':
 +                      if tex.filter == 'FELINE':
 +                              col.itemR(tex, "filter_probes", text="Probes")
 +                      else:
 +                              col.itemR(tex, "filter_eccentricity", text="Eccentricity")
 +
 +class TEXTURE_PT_image_mapping(TextureButtonsPanel):
 +      __label__ = "Image Mapping"
 +      __default_closed__ = True
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'IMAGE')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +              
 +              layout.itemR(tex, "extension")
 +              
 +              split = layout.split()
 +              
 +              if tex.extension == 'REPEAT': 
 +                      col = split.column(align=True)
 +                      col.itemL(text="Repeat:")
 +                      col.itemR(tex, "repeat_x", text="X")
 +                      col.itemR(tex, "repeat_y", text="Y")
 +                      
 +                      col = split.column(align=True)
 +                      col.itemL(text="Mirror:")
 +                      col.itemR(tex, "mirror_x", text="X")
 +                      col.itemR(tex, "mirror_y", text="Y")
 +              elif tex.extension == 'CHECKER': 
 +                      col = split.column(align=True)
 +                      row = col.row()
 +                      row.itemR(tex, "checker_even", text="Even")
 +                      row.itemR(tex, "checker_odd", text="Odd")
 +
 +                      split.itemR(tex, "checker_distance", text="Distance")
 +
 +              layout.itemS()
 +
 +              split = layout.split()
 +              
 +              col = split.column(align=True)
 +              #col.itemR(tex, "crop_rectangle")
 +              col.itemL(text="Crop Minimum:")
 +              col.itemR(tex, "crop_min_x", text="X")
 +              col.itemR(tex, "crop_min_y", text="Y")
 +              
 +              col = split.column(align=True)
 +              col.itemL(text="Crop Maximum:")
 +              col.itemR(tex, "crop_max_x", text="X")
 +              col.itemR(tex, "crop_max_y", text="Y")
 +      
 +class TEXTURE_PT_plugin(TextureButtonsPanel):
 +      __label__ = "Plugin"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'PLUGIN')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +              
 +              layout.itemL(text="Nothing yet")
 +              
 +class TEXTURE_PT_envmap(TextureButtonsPanel):
 +      __label__ = "Environment Map"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'ENVIRONMENT_MAP')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +              
 +              layout.itemL(text="Nothing yet")
 +              
 +class TEXTURE_PT_musgrave(TextureButtonsPanel):
 +      __label__ = "Musgrave"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'MUSGRAVE')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +              
 +              layout.itemR(tex, "musgrave_type")      
 +              
 +              split = layout.split()
 +              
 +              col = split.column()
 +              col.itemR(tex, "highest_dimension", text="Dimension")
 +              col.itemR(tex, "lacunarity")
 +              col.itemR(tex, "octaves")
 +              
 +              col = split.column() 
 +              if (tex.musgrave_type in ('HETERO_TERRAIN', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL')):
 +                      col.itemR(tex, "offset")
 +              if (tex.musgrave_type in ('RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL')):
 +                      col.itemR(tex, "gain")
 +                      col.itemR(tex, "noise_intensity", text="Intensity")
 +              
 +              layout.itemL(text="Noise:")
 +              
 +              layout.itemR(tex, "noise_basis", text="Basis")
 +              
 +              row = layout.row()
 +              row.itemR(tex, "noise_size", text="Size")
 +              row.itemR(tex, "nabla")
 +
 +class TEXTURE_PT_voronoi(TextureButtonsPanel):
 +      __label__ = "Voronoi"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'VORONOI')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +              
 +              split = layout.split()
 +              
 +              col = split.column()   
 +              col.itemL(text="Distance Metric:")
 +              col.itemR(tex, "distance_metric", text="")
 +              sub = col.column()
 +              sub.active = tex.distance_metric == 'MINKOVSKY'
 +              sub.itemR(tex, "minkovsky_exponent", text="Exponent")
 +              col.itemL(text="Coloring:")
 +              col.itemR(tex, "coloring", text="")
 +              col.itemR(tex, "noise_intensity", text="Intensity")
 +              
 +              col = split.column(align=True) 
 +              col.itemL(text="Feature Weights:")
 +              col.itemR(tex, "weight_1", text="1", slider=True)
 +              col.itemR(tex, "weight_2", text="2", slider=True)
 +              col.itemR(tex, "weight_3", text="3", slider=True)
 +              col.itemR(tex, "weight_4", text="4", slider=True)
 +              
 +              layout.itemL(text="Noise:")
 +              
 +              row = layout.row()
 +              row.itemR(tex, "noise_size", text="Size")
 +              row.itemR(tex, "nabla")
 +                      
 +class TEXTURE_PT_distortednoise(TextureButtonsPanel):
 +      __label__ = "Distorted Noise"
 +      
 +      def poll(self, context):
 +              tex = context.texture
 +              return (tex and tex.type == 'DISTORTED_NOISE')
 +
 +      def draw(self, context):
 +              layout = self.layout
 +              
 +              tex = context.texture
 +
 +              layout.itemR(tex, "noise_distortion")
 +              layout.itemR(tex, "noise_basis", text="Basis")
 +              
 +              flow = layout.column_flow()
 +              flow.itemR(tex, "distortion_amount", text="Distortion")
 +              flow.itemR(tex, "noise_size", text="Size")
 +              flow.itemR(tex, "nabla")        
++              
++class TEXTURE_PT_voxeldata(TextureButtonsPanel):
++      __idname__= "TEXTURE_PT_voxeldata"
++      __label__ = "Voxel Data"
++      
++      def poll(self, context):
++              tex = context.texture
++              return (tex and tex.type == 'VOXEL_DATA')
++
++      def draw(self, context):
++              layout = self.layout
++              tex = context.texture
++              vd = tex.voxeldata
++
++              layout.itemR(vd, "file_format")
++              if vd.file_format in ['BLENDER_VOXEL', 'RAW_8BIT']:
++                      layout.itemR(vd, "source_path")
++              if vd.file_format == 'RAW_8BIT':
++                      layout.itemR(vd, "resolution")
++              if vd.file_format == 'SMOKE':
++                      layout.itemR(vd, "object")
++              
++              layout.itemR(vd, "still")
++              if vd.still:
++                      layout.itemR(vd, "still_frame_number")
++              
++              layout.itemR(vd, "interpolation")
++              layout.itemR(vd, "intensity")
++              
++class TEXTURE_PT_pointdensity(TextureButtonsPanel):
++      __idname__= "TEXTURE_PT_pointdensity"
++      __label__ = "Point Density"
++      
++      def poll(self, context):
++              tex = context.texture
++              return (tex and tex.type == 'POINT_DENSITY')
++
++      def draw(self, context):
++              layout = self.layout
++              tex = context.texture
++              pd = tex.pointdensity
++
++              layout.itemR(pd, "point_source")
++
++              layout.itemR(pd, "falloff")
++              
 +
 +bpy.types.register(TEXTURE_PT_context_texture)
 +bpy.types.register(TEXTURE_PT_preview)
 +bpy.types.register(TEXTURE_PT_clouds)
 +bpy.types.register(TEXTURE_PT_wood)
 +bpy.types.register(TEXTURE_PT_marble)
 +bpy.types.register(TEXTURE_PT_magic)
 +bpy.types.register(TEXTURE_PT_blend)
 +bpy.types.register(TEXTURE_PT_stucci)
 +bpy.types.register(TEXTURE_PT_image)
 +bpy.types.register(TEXTURE_PT_image_sampling)
 +bpy.types.register(TEXTURE_PT_image_mapping)
 +bpy.types.register(TEXTURE_PT_plugin)
 +bpy.types.register(TEXTURE_PT_envmap)
 +bpy.types.register(TEXTURE_PT_musgrave)
 +bpy.types.register(TEXTURE_PT_voronoi)
 +bpy.types.register(TEXTURE_PT_distortednoise)
++bpy.types.register(TEXTURE_PT_voxeldata)
++bpy.types.register(TEXTURE_PT_pointdensity)
 +bpy.types.register(TEXTURE_PT_colors)
 +bpy.types.register(TEXTURE_PT_mapping)
 +bpy.types.register(TEXTURE_PT_influence)
index 08a19cada7d49070c91d1c380aa701c11095d1b6,a5832711a81c2383d1bf1a5c4b51072eed54d138..a46014d0a7c4527a47bb92db406a87f619f7c1cc
@@@ -169,7 -170,15 +169,15 @@@ void init_material(Material *ma
        ma->sss_texfac= 0.0f;
        ma->sss_front= 1.0f;
        ma->sss_back= 1.0f;
 -      
 -      ma->vol_density_scale = 1.0f;
 -      ma->vol_stepsize = 0.2f;
 -      ma->vol_shade_stepsize = 0.2f;
 -      ma->vol_absorption = 1.0f;
 -      ma->vol_scattering = 1.0f;
 -      ma->vol_absorption_col[0] = ma->vol_absorption_col[1] = ma->vol_absorption_col[2] = 0.0f;
 -      ma->vol_precache_resolution = 50;
 +
++      ma->vol.density_scale = 1.0f;
++      ma->vol.stepsize = 0.2f;
++      ma->vol.shade_stepsize = 0.2f;
++      ma->vol.absorption = 1.0f;
++      ma->vol.scattering = 1.0f;
++      ma->vol.absorption_col[0] = ma->vol.absorption_col[1] = ma->vol.absorption_col[2] = 0.0f;
++      ma->vol.precache_resolution = 50;
+       
        ma->mode= MA_TRACEBLE|MA_SHADBUF|MA_SHADOW|MA_RADIO|MA_RAYBIAS|MA_TANGENT_STR;
  
        ma->preview = NULL;
index eeffbfe5ef616306be1519123a3e1d1fd8db5d5e,c9cae91da6fd7326ac93364f641803492c2b16cc..234078f66ae9b6ec464be5c61174489ee9ae30fb
@@@ -486,6 -487,16 +489,15 @@@ void default_tex(Tex *tex
                tex->env->depth=0;
        }
  
 -              tex->vd->resolX=50;
+       if (tex->pd) {
+               tex->pd->radius = 0.3f;
+               tex->pd->falloff_type = TEX_PD_FALLOFF_STD;
+       }
+       
+       if (tex->vd) {
 -
++              tex->vd->resol[0] = tex->vd->resol[1] = tex->vd->resol[2] = 0;
+               tex->vd->interp_type=0;
+       }
        pit = tex->plugin;
        if (pit) {
                varstr= pit->varstr;
@@@ -737,9 -748,7 +749,9 @@@ void make_local_texture(Tex *tex
  
  void autotexname(Tex *tex)
  {
 -/*    extern char texstr[20][12];      *//* buttons.c, already in bad lev calls*/
 +      char texstr[20][12]= {"None"  , "Clouds" , "Wood", "Marble", "Magic"  , "Blend",
 +              "Stucci", "Noise"  , "Image", "Plugin", "EnvMap" , "Musgrave",
-               "Voronoi", "DistNoise", "", "", "", "", "", ""};
++              "Voronoi", "DistNoise", "Point Density", "Voxel Data", "", "", "", ""};
        Image *ima;
        char di[FILE_MAXDIR], fi[FILE_MAXFILE];
        
@@@ -887,6 -896,104 +899,102 @@@ void BKE_free_envmap(EnvMap *env
        
  }
  
 -      vd->resolX = 1;
 -      vd->resolY = 1;
 -      vd->resolZ = 1;
+ /* ------------------------------------------------------------------------- */
+ PointDensity *BKE_add_pointdensity(void)
+ {
+       PointDensity *pd;
+       
+       pd= MEM_callocN(sizeof(PointDensity), "pointdensity");
+       pd->flag = 0;
+       pd->radius = 0.3f;
+       pd->falloff_type = TEX_PD_FALLOFF_STD;
+       pd->falloff_softness = 2.0;
+       pd->source = TEX_PD_PSYS;
+       pd->point_tree = NULL;
+       pd->point_data = NULL;
+       pd->noise_size = 0.5f;
+       pd->noise_depth = 1;
+       pd->noise_fac = 1.0f;
+       pd->noise_influence = TEX_PD_NOISE_STATIC;
+       pd->coba = add_colorband(1);
+       pd->speed_scale = 1.0f;
+       pd->totpoints = 0;
+       pd->coba = add_colorband(1);
+       return pd;
+ } 
+ PointDensity *BKE_copy_pointdensity(PointDensity *pd)
+ {
+       PointDensity *pdn;
+       pdn= MEM_dupallocN(pd);
+       pdn->point_tree = NULL;
+       pdn->point_data = NULL;
+       if(pdn->coba) pdn->coba= MEM_dupallocN(pdn->coba);
+       
+       return pdn;
+ }
+ void BKE_free_pointdensitydata(PointDensity *pd)
+ {
+       if (pd->point_tree) {
+               BLI_bvhtree_free(pd->point_tree);
+               pd->point_tree = NULL;
+       }
+       if (pd->point_data) {
+               MEM_freeN(pd->point_data);
+               pd->point_data = NULL;
+       }
+       if(pd->coba) MEM_freeN(pd->coba);
+ }
+ void BKE_free_pointdensity(PointDensity *pd)
+ {
+       BKE_free_pointdensitydata(pd);
+       MEM_freeN(pd);
+ }
+ void BKE_free_voxeldatadata(struct VoxelData *vd)
+ {
+       if (vd->dataset) {
+               MEM_freeN(vd->dataset);
+               vd->dataset = NULL;
+       }
+ }
+  
+ void BKE_free_voxeldata(struct VoxelData *vd)
+ {
+       BKE_free_voxeldatadata(vd);
+       MEM_freeN(vd);
+ }
+  
+ struct VoxelData *BKE_add_voxeldata(void)
+ {
+       VoxelData *vd;
+       vd= MEM_callocN(sizeof(struct VoxelData), "voxeldata");
+       vd->dataset = NULL;
++      vd->resol[0] = vd->resol[1] = vd->resol[2] = 1;
+       vd->interp_type= TEX_VD_NEARESTNEIGHBOR;
+       vd->int_multiplier = 1.0;
+       
+       return vd;
+  }
+  
+ struct VoxelData *BKE_copy_voxeldata(struct VoxelData *vd)
+ {
+       VoxelData *vdn;
+       vdn= MEM_dupallocN(vd); 
+       vdn->dataset = NULL;
+       return vdn;
+ }
  /* ------------------------------------------------------------------------- */
  int BKE_texture_dependsOnTime(const struct Tex *texture)
  {
Simple merge
index 50462d531efb50f6a42e82aef13f6c64428821e1,62aede316828f8be2af73ee78b30afdcd566967a..fe6bc576fbd5c85dc850d74d6f6200ed1d9e4416
@@@ -71,7 -71,10 +71,9 @@@ typedef void (*BVHTree_NearestPointCall
  /* callback must update hit in case it finds a nearest successful hit */
  typedef void (*BVHTree_RayCastCallback) (void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit);
  
+ /* callback to range search query */
+ typedef void (*BVHTree_RangeQuery) (void *userdata, int index, float squared_dist);
  
 -
  BVHTree *BLI_bvhtree_new(int maxsize, float epsilon, char tree_type, char axis);
  void BLI_bvhtree_free(BVHTree *tree);
  
@@@ -93,7 -96,9 +95,11 @@@ int BLI_bvhtree_find_nearest(BVHTree *t
  
  int BLI_bvhtree_ray_cast(BVHTree *tree, const float *co, const float *dir, float radius, BVHTreeRayHit *hit, BVHTree_RayCastCallback callback, void *userdata);
  
 +float BLI_bvhtree_bb_raycast(float *bv, float *light_start, float *light_end, float *pos);
 +
+ /* range query */
+ int BLI_bvhtree_range_query(BVHTree *tree, const float *co, float radius, BVHTree_RangeQuery callback, void *userdata);
  #endif // BLI_KDOPBVH_H
  
index 84de9f9d8625b4f837152e0493dbdcc158698ca7,df37ff457f6149496538ac681a4095557f2ebd10..014c3d52cdad1df9daac193eaeae7ddf025d4deb
@@@ -1526,35 -1524,90 +1526,122 @@@ int BLI_bvhtree_ray_cast(BVHTree *tree
        return data.hit.index;
  }
  
 +float BLI_bvhtree_bb_raycast(float *bv, float *light_start, float *light_end, float *pos)
 +{
 +      BVHRayCastData data;
 +      float dist = 0.0;
 +      int i;
 +
 +      data.hit.dist = FLT_MAX;
 +
 +      // get light direction
 +      data.ray.direction[0] = light_end[0] - light_start[0];
 +      data.ray.direction[1] = light_end[1] - light_start[1];
 +      data.ray.direction[2] = light_end[2] - light_start[2];
 +
 +      data.ray.radius = 0.0;
 +
 +      data.ray.origin[0] = light_start[0];
 +      data.ray.origin[1] = light_start[1];
 +      data.ray.origin[2] = light_start[2];
 +
 +      Normalize(data.ray.direction);
 +      VECCOPY(data.ray_dot_axis, data.ray.direction);
 +
 +      dist = ray_nearest_hit(&data, bv);
 +
 +      if(dist > 0.0)
 +      {
 +              VECADDFAC(pos, light_start, data.ray.direction, dist);
 +      }
 +      return dist;
 +
 +}
 +
+ /*
+  * Range Query - as request by broken :P
+  *
+  * Allocs and fills an array with the indexs of node that are on the given spherical range (center, radius) 
+  * Returns the size of the array.
+  */
+ typedef struct RangeQueryData
+ {
+       BVHTree *tree;
+       const float *center;
+       float radius;                   //squared radius
+       int hits;
+       BVHTree_RangeQuery callback;
+       void *userdata;
+ } RangeQueryData;
+ static void dfs_range_query(RangeQueryData *data, BVHNode *node)
+ {
+       if(node->totnode == 0)
+       {
+               //Calculate the node min-coords (if the node was a point then this is the point coordinates)
+               float co[3];
+               co[0] = node->bv[0];
+               co[1] = node->bv[2];
+               co[2] = node->bv[4];
+       }
+       else
+       {
+               int i;
+               for(i=0; i != node->totnode; i++)
+               {
+                       float nearest[3];
+                       float dist = calc_nearest_point(data->center, node->children[i], nearest);
+                       if(dist < data->radius)
+                       {
+                               //Its a leaf.. call the callback
+                               if(node->children[i]->totnode == 0)
+                               {
+                                       data->hits++;
+                                       data->callback( data->userdata, node->children[i]->index, dist );
+                               }
+                               else
+                                       dfs_range_query( data, node->children[i] );
+                       }
+               }
+       }
+ }
+ int BLI_bvhtree_range_query(BVHTree *tree, const float *co, float radius, BVHTree_RangeQuery callback, void *userdata)
+ {
+       BVHNode * root = tree->nodes[tree->totleaf];
+       RangeQueryData data;
+       data.tree = tree;
+       data.center = co;
+       data.radius = radius*radius;
+       data.hits = 0;
+       data.callback = callback;
+       data.userdata = userdata;
+       if(root != NULL)
+       {
+               float nearest[3];
+               float dist = calc_nearest_point(data.center, root, nearest);
+               if(dist < data.radius)
+               {
+                       //Its a leaf.. call the callback
+                       if(root->totnode == 0)
+                       {
+                               data.hits++;
+                               data.callback( data.userdata, root->index, dist );
+                       }
+                       else
+                               dfs_range_query( &data, root );
+               }
+       }
+       return data.hits;
+ }
index 0000000000000000000000000000000000000000,8a1ca6e59ff50c1e219428f3045256dce3b638f1..b5b2ae793f98cadf56660979b9483ebed0252977
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,311 +1,299 @@@
 -static void point2xyz(int p, int *x, int *y, int *z) {
 -      switch (p) {
 -              case 0: *x=0; *y=0; *z=0; break;
 -              case 1: *x=1; *y=0; *z=0; break;
 -              case 2: *x=0; *y=1; *z=0; break;
 -              case 3: *x=1; *y=1; *z=0; break;
 -              case 4: *x=0; *y=0; *z=1; break;
 -              case 5: *x=1; *y=0; *z=1; break;
 -              case 6: *x=0; *y=1; *z=1; break;
 -              case 7: *x=1; *y=1; *z=1; break;
 -              default:*x=0; *y=0; *z=0;
 -      }
 -}
+ /**
+  *
+  * ***** BEGIN GPL 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.
+  *
+  * 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.
+  *
+  * The Original Code is: all of this file.
+  *
+  * Contributor(s): Matt Ebb, Raul Fernandez Hernandez (Farsthary).
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ #include <math.h>
+ #include "BLI_voxel.h"
+ #include "BKE_utildefines.h"
+ #if defined( _MSC_VER ) && !defined( __cplusplus )
+ # define inline __inline
+ #endif // defined( _MSC_VER ) && !defined( __cplusplus )
+ static inline float D(float *data,  int *res, int x, int y, int z)
+ {
+       CLAMP(x, 0, res[0]-1);
+       CLAMP(y, 0, res[1]-1);
+       CLAMP(z, 0, res[2]-1);
+       return data[ V_I(x, y, z, res) ];
+ }
+ /* *** nearest neighbour *** */
+ /* input coordinates must be in bounding box 0.0 - 1.0 */
+ float voxel_sample_nearest(float *data, int *res, float *co)
+ {
+       int xi, yi, zi;
+       
+       xi = co[0] * res[0];
+       yi = co[1] * res[1];
+       zi = co[2] * res[2];
+       
+       return D(data, res, xi, yi, zi);
+ }
+ /* *** trilinear *** */
+ /* input coordinates must be in bounding box 0.0 - 1.0 */
+ static inline float lerp(float t, float v1, float v2) {
+       return (1.f - t) * v1 + t * v2;
+ }
+ /* trilinear interpolation - taken partly from pbrt's implementation: http://www.pbrt.org */
+ float voxel_sample_trilinear(float *data, int *res, float *co)
+ {
+       float voxx, voxy, voxz;
+       int vx, vy, vz;
+       float dx, dy, dz;
+       float d00, d10, d01, d11, d0, d1, d_final;
+       
+       if (!data) return 0.f;
+       
+       voxx = co[0] * res[0] - 0.5f;
+       voxy = co[1] * res[1] - 0.5f;
+       voxz = co[2] * res[2] - 0.5f;
+       
+       vx = (int)voxx; vy = (int)voxy; vz = (int)voxz;
+       
+       dx = voxx - vx; dy = voxy - vy; dz = voxz - vz;
+       
+       d00 = lerp(dx, D(data, res, vx, vy, vz),                D(data, res, vx+1, vy, vz));
+       d10 = lerp(dx, D(data, res, vx, vy+1, vz),              D(data, res, vx+1, vy+1, vz));
+       d01 = lerp(dx, D(data, res, vx, vy, vz+1),              D(data, res, vx+1, vy, vz+1));
+       d11 = lerp(dx, D(data, res, vx, vy+1, vz+1),    D(data, res, vx+1, vy+1, vz+1));
+       d0 = lerp(dy, d00, d10);
+       d1 = lerp(dy, d01, d11);
+       d_final = lerp(dz, d0, d1);
+       
+       return d_final;
+ }
+ /* *** tricubic *** */
+ int C[64][64] = {
+ { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {-3, 3, 0, 0, 0, 0, 0, 0,-2,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 2,-2, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {-3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0,-3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 9,-9,-9, 9, 0, 0, 0, 0, 6, 3,-6,-3, 0, 0, 0, 0, 6,-6, 3,-3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {-6, 6, 6,-6, 0, 0, 0, 0,-3,-3, 3, 3, 0, 0, 0, 0,-4, 4,-2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2,-2,-1,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 2, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 2, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {-6, 6, 6,-6, 0, 0, 0, 0,-4,-2, 4, 2, 0, 0, 0, 0,-3, 3,-3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2,-1,-2,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 4,-4,-4, 4, 0, 0, 0, 0, 2, 2,-2,-2, 0, 0, 0, 0, 2,-2, 2,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3, 3, 0, 0, 0, 0, 0, 0,-2,-1, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,-2, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0,-1, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,-9,-9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 3,-6,-3, 0, 0, 0, 0, 6,-6, 3,-3, 0, 0, 0, 0, 4, 2, 2, 1, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-6, 6, 6,-6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3,-3, 3, 3, 0, 0, 0, 0,-4, 4,-2, 2, 0, 0, 0, 0,-2,-2,-1,-1, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-6, 6, 6,-6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-4,-2, 4, 2, 0, 0, 0, 0,-3, 3,-3, 3, 0, 0, 0, 0,-2,-1,-2,-1, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4,-4,-4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2,-2,-2, 0, 0, 0, 0, 2,-2, 2,-2, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0},
+ {-3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0,-3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 9,-9, 0, 0,-9, 9, 0, 0, 6, 3, 0, 0,-6,-3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6,-6, 0, 0, 3,-3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 2, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {-6, 6, 0, 0, 6,-6, 0, 0,-3,-3, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-4, 4, 0, 0,-2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2,-2, 0, 0,-1,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0, 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0, 0, 0,-1, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,-9, 0, 0,-9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 3, 0, 0,-6,-3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6,-6, 0, 0, 3,-3, 0, 0, 4, 2, 0, 0, 2, 1, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-6, 6, 0, 0, 6,-6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3,-3, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-4, 4, 0, 0,-2, 2, 0, 0,-2,-2, 0, 0,-1,-1, 0, 0},
+ { 9, 0,-9, 0,-9, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 3, 0,-6, 0,-3, 0, 6, 0,-6, 0, 3, 0,-3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 2, 0, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 9, 0,-9, 0,-9, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 3, 0,-6, 0,-3, 0, 6, 0,-6, 0, 3, 0,-3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 2, 0, 2, 0, 1, 0},
+ {-27,27,27,-27,27,-27,-27,27,-18,-9,18, 9,18, 9,-18,-9,-18,18,-9, 9,18,-18, 9,-9,-18,18,18,-18,-9, 9, 9,-9,-12,-6,-6,-3,12, 6, 6, 3,-12,-6,12, 6,-6,-3, 6, 3,-12,12,-6, 6,-6, 6,-3, 3,-8,-4,-4,-2,-4,-2,-2,-1},
+ {18,-18,-18,18,-18,18,18,-18, 9, 9,-9,-9,-9,-9, 9, 9,12,-12, 6,-6,-12,12,-6, 6,12,-12,-12,12, 6,-6,-6, 6, 6, 6, 3, 3,-6,-6,-3,-3, 6, 6,-6,-6, 3, 3,-3,-3, 8,-8, 4,-4, 4,-4, 2,-2, 4, 4, 2, 2, 2, 2, 1, 1},
+ {-6, 0, 6, 0, 6, 0,-6, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3, 0,-3, 0, 3, 0, 3, 0,-4, 0, 4, 0,-2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0,-2, 0,-1, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0,-6, 0, 6, 0, 6, 0,-6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3, 0,-3, 0, 3, 0, 3, 0,-4, 0, 4, 0,-2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0,-2, 0,-1, 0,-1, 0},
+ {18,-18,-18,18,-18,18,18,-18,12, 6,-12,-6,-12,-6,12, 6, 9,-9, 9,-9,-9, 9,-9, 9,12,-12,-12,12, 6,-6,-6, 6, 6, 3, 6, 3,-6,-3,-6,-3, 8, 4,-8,-4, 4, 2,-4,-2, 6,-6, 6,-6, 3,-3, 3,-3, 4, 2, 4, 2, 2, 1, 2, 1},
+ {-12,12,12,-12,12,-12,-12,12,-6,-6, 6, 6, 6, 6,-6,-6,-6, 6,-6, 6, 6,-6, 6,-6,-8, 8, 8,-8,-4, 4, 4,-4,-3,-3,-3,-3, 3, 3, 3, 3,-4,-4, 4, 4,-2,-2, 2, 2,-4, 4,-4, 4,-2, 2,-2, 2,-2,-2,-2,-2,-1,-1,-1,-1},
+ { 2, 0, 0, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ {-6, 6, 0, 0, 6,-6, 0, 0,-4,-2, 0, 0, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3, 3, 0, 0,-3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2,-1, 0, 0,-2,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 4,-4, 0, 0,-4, 4, 0, 0, 2, 2, 0, 0,-2,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,-2, 0, 0, 2,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-6, 6, 0, 0, 6,-6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-4,-2, 0, 0, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-3, 3, 0, 0,-3, 3, 0, 0,-2,-1, 0, 0,-2,-1, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4,-4, 0, 0,-4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0,-2,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,-2, 0, 0, 2,-2, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0},
+ {-6, 0, 6, 0, 6, 0,-6, 0, 0, 0, 0, 0, 0, 0, 0, 0,-4, 0,-2, 0, 4, 0, 2, 0,-3, 0, 3, 0,-3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0,-1, 0,-2, 0,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0,-6, 0, 6, 0, 6, 0,-6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,-4, 0,-2, 0, 4, 0, 2, 0,-3, 0, 3, 0,-3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,-2, 0,-1, 0,-2, 0,-1, 0},
+ {18,-18,-18,18,-18,18,18,-18,12, 6,-12,-6,-12,-6,12, 6,12,-12, 6,-6,-12,12,-6, 6, 9,-9,-9, 9, 9,-9,-9, 9, 8, 4, 4, 2,-8,-4,-4,-2, 6, 3,-6,-3, 6, 3,-6,-3, 6,-6, 3,-3, 6,-6, 3,-3, 4, 2, 2, 1, 4, 2, 2, 1},
+ {-12,12,12,-12,12,-12,-12,12,-6,-6, 6, 6, 6, 6,-6,-6,-8, 8,-4, 4, 8,-8, 4,-4,-6, 6, 6,-6,-6, 6, 6,-6,-4,-4,-2,-2, 4, 4, 2, 2,-3,-3, 3, 3,-3,-3, 3, 3,-4, 4,-2, 2,-4, 4,-2, 2,-2,-2,-1,-1,-2,-2,-1,-1},
+ { 4, 0,-4, 0,-4, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0,-2, 0,-2, 0, 2, 0,-2, 0, 2, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, 0, 0, 4, 0,-4, 0,-4, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0,-2, 0,-2, 0, 2, 0,-2, 0, 2, 0,-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0},
+ {-12,12,12,-12,12,-12,-12,12,-8,-4, 8, 4, 8, 4,-8,-4,-6, 6,-6, 6, 6,-6, 6,-6,-6, 6, 6,-6,-6, 6, 6,-6,-4,-2,-4,-2, 4, 2, 4, 2,-4,-2, 4, 2,-4,-2, 4, 2,-3, 3,-3, 3,-3, 3,-3, 3,-2,-1,-2,-1,-2,-1,-2,-1},
+ { 8,-8,-8, 8,-8, 8, 8,-8, 4, 4,-4,-4,-4,-4, 4, 4, 4,-4, 4,-4,-4, 4,-4, 4, 4,-4,-4, 4, 4,-4,-4, 4, 2, 2, 2, 2,-2,-2,-2,-2, 2, 2,-2,-2, 2, 2,-2,-2, 2,-2, 2,-2, 2,-2, 2,-2, 1, 1, 1, 1, 1, 1, 1, 1}};
+ static int ijk2n(int i, int j, int k) {
+       return(i+4*j+16*k);
+ }
+ static void tricubic_get_coeff_stacked(float a[64], float x[64]) {
+       int i,j;
+       for (i=0;i<64;i++) {
+               a[i]=(float)(0.0);
+               for (j=0;j<64;j++) {
+                       a[i]+=C[i][j]*x[j];
+               }
+       }
+ }
++
+ static void tricubic_get_coeff(float a[64], float f[8], float dfdx[8], float dfdy[8], float dfdz[8], float d2fdxdy[8], float d2fdxdz[8], float d2fdydz[8], float d3fdxdydz[8]) {
+       int i;
+       float x[64];
+       for (i=0;i<8;i++) {
+               x[0+i]=f[i];
+               x[8+i]=dfdx[i];
+               x[16+i]=dfdy[i];
+               x[24+i]=dfdz[i];
+               x[32+i]=d2fdxdy[i];
+               x[40+i]=d2fdxdz[i];
+               x[48+i]=d2fdydz[i];
+               x[56+i]=d3fdxdydz[i];
+       }
+       tricubic_get_coeff_stacked(a,x);
+ }
+ static float tricubic_eval(float a[64], float x, float y, float z) {
+       int i,j,k;
+       float ret=(float)(0.0);
+       
+       for (i=0;i<4;i++) {
+               for (j=0;j<4;j++) {
+                       for (k=0;k<4;k++) {
+                               ret+=a[ijk2n(i,j,k)]*pow(x,i)*pow(y,j)*pow(z,k);
+                       }
+               }
+       }
+       return(ret);
+ }
+ /* tricubic interpolation
+  * from 'libtricubic': http://www.lekien.com/~francois/software/tricubic/ 
+  * input coordinates must be in bounding box 0.0 - 1.0 */
+ float voxel_sample_tricubic(float *data, int *res, float *co)
+ {
+       float xx, yy, zz;
+       int xi,yi,zi;
+       int *n = res;
+       float dx,dy,dz;
+       float a[64];
+       
+       xx = co[0] * res[0] - 0.5f;
+       yy = co[1] * res[1] - 0.5f;
+       zz = co[2] * res[2] - 0.5f;
+       
+       xi = (int)xx; yi = (int)yy; zi = (int)zz;
+       
+       {
+               float fval[8]={data[V_I(xi,yi,zi,n)],data[V_I(xi+1,yi,zi,n)],data[V_I(xi,yi+1,zi,n)],data[V_I(xi+1,yi+1,zi,n)],data[V_I(xi,yi,zi+1,n)],data[V_I(xi+1,yi,zi+1,n)],data[V_I(xi,yi+1,zi+1,n)],data[V_I(xi+1,yi+1,zi+1,n)]}; 
+               
+               float dfdxval[8]={0.5f*(data[V_I(xi+1,yi,zi,n)]-data[V_I(xi-1,yi,zi,n)]),0.5f*(data[V_I(xi+2,yi,zi,n)]-data[V_I(xi,yi,zi,n)]),
+                       0.5f*(data[V_I(xi+1,yi+1,zi,n)]-data[V_I(xi-1,yi+1,zi,n)]),0.5f*(data[V_I(xi+2,yi+1,zi,n)]-data[V_I(xi,yi+1,zi,n)]),
+                       0.5f*(data[V_I(xi+1,yi,zi+1,n)]-data[V_I(xi-1,yi,zi+1,n)]),0.5f*(data[V_I(xi+2,yi,zi+1,n)]-data[V_I(xi,yi,zi+1,n)]),
+                       0.5f*(data[V_I(xi+1,yi+1,zi+1,n)]-data[V_I(xi-1,yi+1,zi+1,n)]),
+                       0.5f*(data[V_I(xi+2,yi+1,zi+1,n)]-data[V_I(xi,yi+1,zi+1,n)])};                                          
+               
+               float dfdyval[8]={0.5f*(data[V_I(xi,yi+1,zi,n)]-data[V_I(xi,yi-1,zi,n)]),0.5f*(data[V_I(xi+1,yi+1,zi,n)]-data[V_I(xi+1,yi-1,zi,n)]),
+                       0.5f*(data[V_I(xi,yi+2,zi,n)]-data[V_I(xi,yi,zi,n)]),0.5f*(data[V_I(xi+1,yi+2,zi,n)]-data[V_I(xi+1,yi,zi,n)]),
+                       0.5f*(data[V_I(xi,yi+1,zi+1,n)]-data[V_I(xi,yi-1,zi+1,n)]),0.5f*(data[V_I(xi+1,yi+1,zi+1,n)]-data[V_I(xi+1,yi-1,zi+1,n)]),
+                       0.5f*(data[V_I(xi,yi+2,zi+1,n)]-data[V_I(xi,yi,zi+1,n)]),
+                       0.5f*(data[V_I(xi+1,yi+2,zi+1,n)]-data[V_I(xi+1,yi,zi+1,n)])};                                           
+               
+               float dfdzval[8]={0.5f*(data[V_I(xi,yi,zi+1,n)]-data[V_I(xi,yi,zi-1,n)]),0.5f*(data[V_I(xi+1,yi,zi+1,n)]-data[V_I(xi+1,yi,zi-1,n)]),
+                       0.5f*(data[V_I(xi,yi+1,zi+1,n)]-data[V_I(xi,yi+1,zi-1,n)]),0.5f*(data[V_I(xi+1,yi+1,zi+1,n)]-data[V_I(xi+1,yi+1,zi-1,n)]),
+                       0.5f*(data[V_I(xi,yi,zi+2,n)]-data[V_I(xi,yi,zi,n)]),0.5f*(data[V_I(xi+1,yi,zi+2,n)]-data[V_I(xi+1,yi,zi,n)]),
+                       0.5f*(data[V_I(xi,yi+1,zi+2,n)]-data[V_I(xi,yi+1,zi,n)]),
+                       0.5f*(data[V_I(xi+1,yi+1,zi+2,n)]-data[V_I(xi+1,yi+1,zi,n)])};                                           
+               
+               float d2fdxdyval[8]={0.25*(data[V_I(xi+1,yi+1,zi,n)]-data[V_I(xi-1,yi+1,zi,n)]-data[V_I(xi+1,yi-1,zi,n)]+data[V_I(xi-1,yi-1,zi,n)]),
+                       0.25*(data[V_I(xi+2,yi+1,zi,n)]-data[V_I(xi,yi+1,zi,n)]-data[V_I(xi+2,yi-1,zi,n)]+data[V_I(xi,yi-1,zi,n)]),
+                       0.25*(data[V_I(xi+1,yi+2,zi,n)]-data[V_I(xi-1,yi+2,zi,n)]-data[V_I(xi+1,yi,zi,n)]+data[V_I(xi-1,yi,zi,n)]),
+                       0.25*(data[V_I(xi+2,yi+2,zi,n)]-data[V_I(xi,yi+2,zi,n)]-data[V_I(xi+2,yi,zi,n)]+data[V_I(xi,yi,zi,n)]),
+                       0.25*(data[V_I(xi+1,yi+1,zi+1,n)]-data[V_I(xi-1,yi+1,zi+1,n)]-data[V_I(xi+1,yi-1,zi+1,n)]+data[V_I(xi-1,yi-1,zi+1,n)]),
+                       0.25*(data[V_I(xi+2,yi+1,zi+1,n)]-data[V_I(xi,yi+1,zi+1,n)]-data[V_I(xi+2,yi-1,zi+1,n)]+data[V_I(xi,yi-1,zi+1,n)]),
+                       0.25*(data[V_I(xi+1,yi+2,zi+1,n)]-data[V_I(xi-1,yi+2,zi+1,n)]-data[V_I(xi+1,yi,zi+1,n)]+data[V_I(xi-1,yi,zi+1,n)]),
+                       0.25*(data[V_I(xi+2,yi+2,zi+1,n)]-data[V_I(xi,yi+2,zi+1,n)]-data[V_I(xi+2,yi,zi+1,n)]+data[V_I(xi,yi,zi+1,n)])};                                                 
+               
+               float d2fdxdzval[8]={0.25f*(data[V_I(xi+1,yi,zi+1,n)]-data[V_I(xi-1,yi,zi+1,n)]-data[V_I(xi+1,yi,zi-1,n)]+data[V_I(xi-1,yi,zi-1,n)]),
+                       0.25f*(data[V_I(xi+2,yi,zi+1,n)]-data[V_I(xi,yi,zi+1,n)]-data[V_I(xi+2,yi,zi-1,n)]+data[V_I(xi,yi,zi-1,n)]),
+                       0.25f*(data[V_I(xi+1,yi+1,zi+1,n)]-data[V_I(xi-1,yi+1,zi+1,n)]-data[V_I(xi+1,yi+1,zi-1,n)]+data[V_I(xi-1,yi+1,zi-1,n)]),
+                       0.25f*(data[V_I(xi+2,yi+1,zi+1,n)]-data[V_I(xi,yi+1,zi+1,n)]-data[V_I(xi+2,yi+1,zi-1,n)]+data[V_I(xi,yi+1,zi-1,n)]),
+                       0.25f*(data[V_I(xi+1,yi,zi+2,n)]-data[V_I(xi-1,yi,zi+2,n)]-data[V_I(xi+1,yi,zi,n)]+data[V_I(xi-1,yi,zi,n)]),
+                       0.25f*(data[V_I(xi+2,yi,zi+2,n)]-data[V_I(xi,yi,zi+2,n)]-data[V_I(xi+2,yi,zi,n)]+data[V_I(xi,yi,zi,n)]),
+                       0.25f*(data[V_I(xi+1,yi+1,zi+2,n)]-data[V_I(xi-1,yi+1,zi+2,n)]-data[V_I(xi+1,yi+1,zi,n)]+data[V_I(xi-1,yi+1,zi,n)]),
+                       0.25f*(data[V_I(xi+2,yi+1,zi+2,n)]-data[V_I(xi,yi+1,zi+2,n)]-data[V_I(xi+2,yi+1,zi,n)]+data[V_I(xi,yi+1,zi,n)])};
+               
+               
+               float d2fdydzval[8]={0.25f*(data[V_I(xi,yi+1,zi+1,n)]-data[V_I(xi,yi-1,zi+1,n)]-data[V_I(xi,yi+1,zi-1,n)]+data[V_I(xi,yi-1,zi-1,n)]),
+                       0.25f*(data[V_I(xi+1,yi+1,zi+1,n)]-data[V_I(xi+1,yi-1,zi+1,n)]-data[V_I(xi+1,yi+1,zi-1,n)]+data[V_I(xi+1,yi-1,zi-1,n)]),
+                       0.25f*(data[V_I(xi,yi+2,zi+1,n)]-data[V_I(xi,yi,zi+1,n)]-data[V_I(xi,yi+2,zi-1,n)]+data[V_I(xi,yi,zi-1,n)]),
+                       0.25f*(data[V_I(xi+1,yi+2,zi+1,n)]-data[V_I(xi+1,yi,zi+1,n)]-data[V_I(xi+1,yi+2,zi-1,n)]+data[V_I(xi+1,yi,zi-1,n)]),
+                       0.25f*(data[V_I(xi,yi+1,zi+2,n)]-data[V_I(xi,yi-1,zi+2,n)]-data[V_I(xi,yi+1,zi,n)]+data[V_I(xi,yi-1,zi,n)]),
+                       0.25f*(data[V_I(xi+1,yi+1,zi+2,n)]-data[V_I(xi+1,yi-1,zi+2,n)]-data[V_I(xi+1,yi+1,zi,n)]+data[V_I(xi+1,yi-1,zi,n)]),
+                       0.25f*(data[V_I(xi,yi+2,zi+2,n)]-data[V_I(xi,yi,zi+2,n)]-data[V_I(xi,yi+2,zi,n)]+data[V_I(xi,yi,zi,n)]),
+                       0.25f*(data[V_I(xi+1,yi+2,zi+2,n)]-data[V_I(xi+1,yi,zi+2,n)]-data[V_I(xi+1,yi+2,zi,n)]+data[V_I(xi+1,yi,zi,n)])};
+               
+               
+               float d3fdxdydzval[8]={0.125f*(data[V_I(xi+1,yi+1,zi+1,n)]-data[V_I(xi-1,yi+1,zi+1,n)]-data[V_I(xi+1,yi-1,zi+1,n)]+data[V_I(xi-1,yi-1,zi+1,n)]-data[V_I(xi+1,yi+1,zi-1,n)]+data[V_I(xi-1,yi+1,zi-1,n)]+data[V_I(xi+1,yi-1,zi-1,n)]-data[V_I(xi-1,yi-1,zi-1,n)]),
+                       0.125f*(data[V_I(xi+2,yi+1,zi+1,n)]-data[V_I(xi,yi+1,zi+1,n)]-data[V_I(xi+2,yi-1,zi+1,n)]+data[V_I(xi,yi-1,zi+1,n)]-data[V_I(xi+2,yi+1,zi-1,n)]+data[V_I(xi,yi+1,zi-1,n)]+data[V_I(xi+2,yi-1,zi-1,n)]-data[V_I(xi,yi-1,zi-1,n)]),
+                       0.125f*(data[V_I(xi+1,yi+2,zi+1,n)]-data[V_I(xi-1,yi+2,zi+1,n)]-data[V_I(xi+1,yi,zi+1,n)]+data[V_I(xi-1,yi,zi+1,n)]-data[V_I(xi+1,yi+2,zi-1,n)]+data[V_I(xi-1,yi+2,zi-1,n)]+data[V_I(xi+1,yi,zi-1,n)]-data[V_I(xi-1,yi,zi-1,n)]),
+                       0.125f*(data[V_I(xi+2,yi+2,zi+1,n)]-data[V_I(xi,yi+2,zi+1,n)]-data[V_I(xi+2,yi,zi+1,n)]+data[V_I(xi,yi,zi+1,n)]-data[V_I(xi+2,yi+2,zi-1,n)]+data[V_I(xi,yi+2,zi-1,n)]+data[V_I(xi+2,yi,zi-1,n)]-data[V_I(xi,yi,zi-1,n)]),
+                       0.125f*(data[V_I(xi+1,yi+1,zi+2,n)]-data[V_I(xi-1,yi+1,zi+2,n)]-data[V_I(xi+1,yi-1,zi+2,n)]+data[V_I(xi-1,yi-1,zi+2,n)]-data[V_I(xi+1,yi+1,zi,n)]+data[V_I(xi-1,yi+1,zi,n)]+data[V_I(xi+1,yi-1,zi,n)]-data[V_I(xi-1,yi-1,zi,n)]),
+                       0.125f*(data[V_I(xi+2,yi+1,zi+2,n)]-data[V_I(xi,yi+1,zi+2,n)]-data[V_I(xi+2,yi-1,zi+2,n)]+data[V_I(xi,yi-1,zi+2,n)]-data[V_I(xi+2,yi+1,zi,n)]+data[V_I(xi,yi+1,zi,n)]+data[V_I(xi+2,yi-1,zi,n)]-data[V_I(xi,yi-1,zi,n)]),
+                       0.125f*(data[V_I(xi+1,yi+2,zi+2,n)]-data[V_I(xi-1,yi+2,zi+2,n)]-data[V_I(xi+1,yi,zi+2,n)]+data[V_I(xi-1,yi,zi+2,n)]-data[V_I(xi+1,yi+2,zi,n)]+data[V_I(xi-1,yi+2,zi,n)]+data[V_I(xi+1,yi,zi,n)]-data[V_I(xi-1,yi,zi,n)]),
+                       0.125f*(data[V_I(xi+2,yi+2,zi+2,n)]-data[V_I(xi,yi+2,zi+2,n)]-data[V_I(xi+2,yi,zi+2,n)]+data[V_I(xi,yi,zi+2,n)]-data[V_I(xi+2,yi+2,zi,n)]+data[V_I(xi,yi+2,zi,n)]+data[V_I(xi+2,yi,zi,n)]-data[V_I(xi,yi,zi,n)])};
+               
+               
+               tricubic_get_coeff(a,fval,dfdxval,dfdyval,dfdzval,d2fdxdyval,d2fdxdzval,d2fdydzval,d3fdxdydzval);
+       }
+       
+       dx = xx-xi;
+       dy = yy-yi;
+       dz = zz-zi;
+       
+       return tricubic_eval(a,dx,dy,dz);
+       
+ }
index 4515032218ebf2da132602109baaa5dc0902a915,59c11297478f75991b238741a00550ee7a9562af..4ee71ea92dbb729b71ce004f331cb77b806815f2
@@@ -2820,6 -2505,7 +2820,8 @@@ static void lib_link_texture(FileData *
                        tex->ima= newlibadr_us(fd, tex->id.lib, tex->ima);
                        tex->ipo= newlibadr_us(fd, tex->id.lib, tex->ipo);
                        if(tex->env) tex->env->object= newlibadr(fd, tex->id.lib, tex->env->object);
+                       if(tex->pd) tex->pd->object= newlibadr(fd, tex->id.lib, tex->pd->object);
++                      if(tex->vd) tex->vd->object= newlibadr(fd, tex->id.lib, tex->vd->object);
  
                        if(tex->nodetree)
                                lib_link_ntree(fd, &tex->id, tex->nodetree);
@@@ -2852,6 -2535,17 +2854,16 @@@ static void direct_link_texture(FileDat
                memset(tex->env->cube, 0, 6*sizeof(void *));
                tex->env->ok= 0;
        }
 -
+       tex->pd= newdataadr(fd, tex->pd);
+       if(tex->pd) {
+               tex->pd->point_tree = NULL;
+               tex->pd->coba= newdataadr(fd, tex->pd->coba);
+       }
+       
+       tex->vd= newdataadr(fd, tex->vd);
+       if(tex->vd) {
+               tex->vd->dataset = NULL;
+       }
        
        tex->nodetree= newdataadr(fd, tex->nodetree);
        if(tex->nodetree)
@@@ -9352,199 -8071,87 +9364,208 @@@ static void do_versions(FileData *fd, L
                }
        }
  
 -      if (main->versionfile < 248 || (main->versionfile == 248 && main->subversionfile < 3)) {
 -              Tex *tex;
 -              Material *ma;
 -              
 -              /* blend texture extrapolation */
 -              for(tex=main->tex.first; tex; tex= tex->id.next) {
 -                      if (tex->type == TEX_BLEND)
 -                              tex->extend = TEX_EXTEND;
 -              }
 -              
 -              for(ma=main->mat.first; ma; ma= ma->id.next) {
 -                      if (ma->vol_shadeflag & 2) { // old MA_VOL_ATTENUATED
 -                              ma->vol_shade_type = MA_VOL_SHADE_SINGLE;
 -                              ma->vol_ms_diff = 0.5f;
 -                              ma->vol_ms_steps = 5;
 -                              ma->vol_ms_intensity = 1.0;
 -                      }
 -              }
 +      if (main->versionfile < 250 || (main->versionfile == 250 && main->subversionfile < 1)) {
        }
  
 -      if (main->versionfile < 248 || (main->versionfile == 248 && main->subversionfile < 2)) {
 +      /* TODO: should be moved into one of the version blocks once this branch moves to trunk and we can
 +         bump the version (or sub-version.) */
 +      {
 +              World *wo;
 +              Object *ob;
 +              Material *ma;
 +              Tex *tex;
                Scene *sce;
 -              
 -              /* Note, these will need to be added for painting */
 -              for (sce= main->scene.first; sce; sce= sce->id.next) {
 -                      sce->toolsettings->imapaint.seam_bleed = 2;
 -                      sce->toolsettings->imapaint.normal_angle = 80;
 +              ToolSettings *ts;
 +              PTCacheID *pid;
 +              ListBase pidlist;
 +              int i, a;
  
 -                      /* initialize skeleton generation toolsettings */
 -                      sce->toolsettings->skgen_resolution = 250;
 -                      sce->toolsettings->skgen_threshold_internal     = 0.1f;
 -                      sce->toolsettings->skgen_threshold_external     = 0.1f;
 -                      sce->toolsettings->skgen_angle_limit                    = 30.0f;
 -                      sce->toolsettings->skgen_length_ratio                   = 1.3f;
 -                      sce->toolsettings->skgen_length_limit                   = 1.5f;
 -                      sce->toolsettings->skgen_correlation_limit              = 0.98f;
 -                      sce->toolsettings->skgen_symmetry_limit                 = 0.1f;
 -                      sce->toolsettings->skgen_postpro = SKGEN_SMOOTH;
 -                      sce->toolsettings->skgen_postpro_passes = 3;
 -                      sce->toolsettings->skgen_options = SKGEN_FILTER_INTERNAL|SKGEN_FILTER_EXTERNAL|SKGEN_FILTER_SMART|SKGEN_SUB_CORRELATION|SKGEN_HARMONIC;
 -                      sce->toolsettings->skgen_subdivisions[0] = SKGEN_SUB_CORRELATION;
 -                      sce->toolsettings->skgen_subdivisions[1] = SKGEN_SUB_LENGTH;
 -                      sce->toolsettings->skgen_subdivisions[2] = SKGEN_SUB_ANGLE;
 +              for(ob = main->object.first; ob; ob = ob->id.next) {
 +                      //BKE_ptcache_ids_from_object(&pidlist, ob);
  
 -                      
 -                      sce->toolsettings->skgen_retarget_angle_weight = 1.0f;
 -                      sce->toolsettings->skgen_retarget_length_weight = 1.0f;
 -                      sce->toolsettings->skgen_retarget_distance_weight = 1.0f;
 -      
 -                      /* Skeleton Sketching */
 -                      sce->toolsettings->bone_sketching = 0;
 -                      sce->toolsettings->skgen_retarget_roll = SK_RETARGET_ROLL_VIEW;
 -              }
 -      }
 +                      //for(pid=pidlist.first; pid; pid=pid->next) {
 +                      //      if(pid->ptcaches->first == NULL)
 +                      //              pid->ptcaches->first = pid->ptcaches->last = pid->cache;
 +                      //}
  
 -      if (main->versionfile < 248 || (main->versionfile == 248 && main->subversionfile < 3)) {
 -              Object *ob;
 +                      //BLI_freelistN(&pidlist);
  
 -              /* Adjustments needed after Bullets update */
 -              for(ob = main->object.first; ob; ob= ob->id.next) {
 -                      ob->damping *= 0.635f;
 -                      ob->rdamping = 0.1 + (0.59f * ob->rdamping);
 +                      if(ob->type == OB_MESH) {
 +                              Mesh *me = newlibadr(fd, lib, ob->data);
 +                              void *olddata = ob->data;
 +                              ob->data = me;
 +
 +                              if(me && me->id.lib==NULL && me->mr) { /* XXX - library meshes crash on loading most yoFrankie levels, the multires pointer gets invalid -  Campbell */
 +                                      MultiresLevel *lvl;
 +                                      ModifierData *md;
 +                                      MultiresModifierData *mmd;
 +                                      DerivedMesh *dm, *orig;
 +
 +                                      /* Load original level into the mesh */
 +                                      lvl = me->mr->levels.first;
 +                                      CustomData_free_layers(&me->vdata, CD_MVERT, lvl->totvert);
 +                                      CustomData_free_layers(&me->edata, CD_MEDGE, lvl->totedge);
 +                                      CustomData_free_layers(&me->fdata, CD_MFACE, lvl->totface);
 +                                      me->totvert = lvl->totvert;
 +                                      me->totedge = lvl->totedge;
 +                                      me->totface = lvl->totface;
 +                                      me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, me->totvert);
 +                                      me->medge = CustomData_add_layer(&me->edata, CD_MEDGE, CD_CALLOC, NULL, me->totedge);
 +                                      me->mface = CustomData_add_layer(&me->fdata, CD_MFACE, CD_CALLOC, NULL, me->totface);
 +                                      memcpy(me->mvert, me->mr->verts, sizeof(MVert) * me->totvert);
 +                                      for(i = 0; i < me->totedge; ++i) {
 +                                              me->medge[i].v1 = lvl->edges[i].v[0];
 +                                              me->medge[i].v2 = lvl->edges[i].v[1];
 +                                      }
 +                                      for(i = 0; i < me->totface; ++i) {
 +                                              me->mface[i].v1 = lvl->faces[i].v[0];
 +                                              me->mface[i].v2 = lvl->faces[i].v[1];
 +                                              me->mface[i].v3 = lvl->faces[i].v[2];
 +                                              me->mface[i].v4 = lvl->faces[i].v[3];
 +                                      }
 +
 +                                      /* Add a multires modifier to the object */
 +                                      md = ob->modifiers.first;
 +                                      while(md && modifierType_getInfo(md->type)->type == eModifierTypeType_OnlyDeform)
 +                                              md = md->next;                          
 +                                      mmd = (MultiresModifierData*)modifier_new(eModifierType_Multires);
 +                                      BLI_insertlinkbefore(&ob->modifiers, md, mmd);
 +
 +                                      multiresModifier_subdivide(mmd, ob, me->mr->level_count - 1, 1, 0);
 +
 +                                      mmd->lvl = mmd->totlvl;
 +                                      orig = CDDM_from_mesh(me, NULL);
 +                                      dm = multires_dm_create_from_derived(mmd, orig, me, 0, 0);
 +                                       
 +                                      multires_load_old(dm, me->mr);
 +
 +                                      MultiresDM_mark_as_modified(dm);
 +                                      dm->release(dm);
 +                                      orig->release(orig);
 +
 +                                      /* Remove the old multires */
 +                                      multires_free(me->mr);
 +                                      me->mr = NULL;
 +                              }
 +
 +                              ob->data = olddata;
 +                      }
 +
 +                      if(ob->totcol && ob->matbits == NULL) {
 +                              int a;
 +
 +                              ob->matbits= MEM_callocN(sizeof(char)*ob->totcol, "ob->matbits");
 +                              for(a=0; a<ob->totcol; a++)
 +                                      ob->matbits[a]= ob->colbits & (1<<a);
 +                      }
                }
 -      }
 -      
 -      if (main->versionfile < 248 || (main->versionfile == 248 && main->subversionfile < 4)) {
 -              Scene *sce;
 -              World *wrld;
  
 -              /*  Dome (Fisheye) default parameters  */
 -              for (sce= main->scene.first; sce; sce= sce->id.next) {
 -                      sce->r.domeangle = 180;
 -                      sce->r.domemode = 1;
 -                      sce->r.domesize = 1.0f;
 -                      sce->r.domeres = 4;
 -                      sce->r.domeresbuf = 1.0f;
 +              /* texture filter */
 +              for(tex = main->tex.first; tex; tex = tex->id.next) {
 +                      if(tex->afmax == 0)
 +                              tex->afmax= 8;
                }
 -              /* DBVT culling by default */
 -              for(wrld=main->world.first; wrld; wrld= wrld->id.next) {
 -                      wrld->mode |= WO_DBVT_CULLING;
 -                      wrld->occlusionRes = 128;
 +
 +              for(ma = main->mat.first; ma; ma = ma->id.next) {
 +                      if(ma->mode & MA_WIRE) {
 +                              ma->material_type= MA_TYPE_WIRE;
 +                              ma->mode &= ~MA_WIRE;
 +                      }
 +                      if(ma->mode & MA_HALO) {
 +                              ma->material_type= MA_TYPE_HALO;
 +                              ma->mode &= ~MA_HALO;
 +                      }
 +
 +                      /* set new bump for unused slots */
 +                      for(a=0; a<MAX_MTEX; a++) {
 +                              if(ma->mtex[a]) {
 +                                      tex= ma->mtex[a]->tex;
 +                                      if(!tex)
 +                                              ma->mtex[a]->texflag |= MTEX_NEW_BUMP;
 +                                      else {
 +                                              tex= (Tex*)newlibadr(fd, ma->id.lib, tex);
 +                                              if(tex && tex->type == 0) /* invalid type */
 +                                                      ma->mtex[a]->texflag |= MTEX_NEW_BUMP;
 +                                      }
 +                              }
 +                      }
++                      
++                      /* volume rendering settings */
++                      ma->vol.density_scale = 1.0f;
++                      ma->vol.stepsize = 0.2f;
++                      ma->vol.shade_stepsize = 0.2f;
++                      ma->vol.absorption = 1.0f;
++                      ma->vol.scattering = 1.0f;
++                      ma->vol.absorption_col[0] = ma->vol.absorption_col[1] = ma->vol.absorption_col[2] = 0.0f;
++                      ma->vol.precache_resolution = 50;
 +              }
 +
 +              for(sce = main->scene.first; sce; sce = sce->id.next) {
 +                      ts= sce->toolsettings;
 +                      if(ts->normalsize == 0.0 || !ts->uv_selectmode || ts->vgroup_weight == 0.0) {
 +                              ts->normalsize= 0.1f;
 +                              ts->selectmode= SCE_SELECT_VERTEX;
 +                              
 +                              /* autokeying - setting should be taken from the user-prefs
 +                               * but the userprefs version may not have correct flags set 
 +                               * (i.e. will result in blank box when enabled)
 +                               */
 +                              ts->autokey_mode= U.autokey_mode;
 +                              if (ts->autokey_mode == 0) 
 +                                      ts->autokey_mode= 2; /* 'add/replace' but not on */
 +                              ts->uv_selectmode= UV_SELECT_VERTEX;
 +                              ts->vgroup_weight= 1.0f;
 +                      }
 +
 +                      /* Game Settings */
 +                      //Dome
 +                      sce->gm.dome.angle = sce->r.domeangle;
 +                      sce->gm.dome.mode = sce->r.domemode;
 +                      sce->gm.dome.res = sce->r.domeres;
 +                      sce->gm.dome.resbuf = sce->r.domeresbuf;
 +                      sce->gm.dome.tilt = sce->r.dometilt;
 +                      sce->gm.dome.warptext = sce->r.dometext;
 +
 +                      //Stand Alone
 +                      sce->gm.fullscreen = sce->r.fullscreen;
 +                      sce->gm.xplay = sce->r.xplay;
 +                      sce->gm.yplay = sce->r.yplay;
 +                      sce->gm.freqplay = sce->r.freqplay;
 +                      sce->gm.depth = sce->r.depth;
 +                      sce->gm.attrib = sce->r.attrib;
 +
 +                      //Stereo
 +                      sce->gm.xsch = sce->r.xsch;
 +                      sce->gm.ysch = sce->r.ysch;
 +                      sce->gm.stereomode = sce->r.stereomode;
 +                      /* reassigning stereomode NO_STEREO and DOME to a separeted flag*/
 +                      if (sce->gm.stereomode == 1){ //1 = STEREO_NOSTEREO
 +                              sce->gm.stereoflag = STEREO_NOSTEREO;
 +                              sce->gm.stereomode = STEREO_ANAGLYPH;
 +                      }
 +                      else if(sce->gm.stereomode == 8){ //8 = STEREO_DOME
 +                              sce->gm.stereoflag = STEREO_DOME;
 +                              sce->gm.stereomode = STEREO_ANAGLYPH;
 +                      }
 +                      else
 +                              sce->gm.stereoflag = STEREO_ENABLED;
 +
 +                      //Framing
 +                      sce->gm.framing = sce->framing;
 +                      sce->gm.xplay = sce->r.xplay;
 +                      sce->gm.yplay = sce->r.yplay;
 +                      sce->gm.freqplay= sce->r.freqplay;
 +                      sce->gm.depth= sce->r.depth;
 +
 +                      //Physic (previously stored in world)
 +                      sce->gm.gravity =9.8f;
 +                      sce->gm.physicsEngine= WOPHY_BULLET;// Bullet by default
 +                      sce->gm.mode = WO_DBVT_CULLING; // DBVT culling by default
 +                      sce->gm.occlusionRes = 128;
 +                      sce->gm.ticrate = 60;
 +                      sce->gm.maxlogicstep = 5;
 +                      sce->gm.physubstep = 1;
 +                      sce->gm.maxphystep = 5;
                }
        }
  
index d8841962e7b51d5e86e27a2f30186acb9b596d76,739b0f11e7eb1084da030d6fa0766b64b83ef5a5..be2a75709842384f3d8e982fffcf49e2bf09a9fe
@@@ -1569,6 -1335,11 +1569,11 @@@ static void write_textures(WriteData *w
                        if(tex->type == TEX_PLUGIN && tex->plugin) writestruct(wd, DATA, "PluginTex", 1, tex->plugin);
                        if(tex->coba) writestruct(wd, DATA, "ColorBand", 1, tex->coba);
                        if(tex->type == TEX_ENVMAP && tex->env) writestruct(wd, DATA, "EnvMap", 1, tex->env);
 -                      if(tex->pd) {
++                      if(tex->type == TEX_POINTDENSITY && tex->pd) {
+                               writestruct(wd, DATA, "PointDensity", 1, tex->pd);
+                               if(tex->pd->coba) writestruct(wd, DATA, "ColorBand", 1, tex->pd->coba);
+                       }
 -                      if(tex->vd) writestruct(wd, DATA, "VoxelData", 1, tex->vd);
++                      if(tex->type == TEX_VOXELDATA && tex->vd) writestruct(wd, DATA, "VoxelData", 1, tex->vd);
                        
                        /* nodetree is integral part of texture, no libdata */
                        if(tex->nodetree) {
index c5a741b11ed49a1adb0c35002cb4092f26399f44,0000000000000000000000000000000000000000..4f09faaf7c16e9a6dc7f596ff83f92291e0d3782
mode 100644,000000..100644
--- /dev/null
@@@ -1,987 -1,0 +1,989 @@@
 +/* 
 + * $Id$
 + *
 + * ***** BEGIN GPL 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.
 + *
 + * 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) Blender Foundation.
 + * All rights reserved.
 + *
 + * The Original Code is: all of this file.
 + *
 + * Contributor(s): none yet.
 + *
 + * ***** END GPL LICENSE BLOCK *****
 + */
 +
 +/* global includes */
 +
 +#include <stdlib.h>
 +#include <math.h>
 +#include <string.h>
 +
 +#ifndef WIN32
 +#include <unistd.h>
 +#else
 +#include <io.h>
 +#endif   
 +#include "MEM_guardedalloc.h"
 +
 +#include "BLO_readfile.h" 
 +
 +#include "BLI_arithb.h"
 +#include "BLI_blenlib.h"
 +#include "BLI_threads.h"
 +
 +#include "DNA_texture_types.h"
 +#include "DNA_world_types.h"
 +#include "DNA_camera_types.h"
 +#include "DNA_image_types.h"
 +#include "DNA_material_types.h"
 +#include "DNA_node_types.h"
 +#include "DNA_object_types.h"
 +#include "DNA_lamp_types.h"
 +#include "DNA_space_types.h"
 +#include "DNA_view3d_types.h"
 +#include "DNA_scene_types.h"
 +#include "DNA_screen_types.h"
 +
 +#include "BKE_context.h"
 +#include "BKE_depsgraph.h"
 +#include "BKE_global.h"
 +#include "BKE_image.h"
 +#include "BKE_icons.h"
 +#include "BKE_library.h"
 +#include "BKE_main.h"
 +#include "BKE_texture.h"
 +#include "BKE_material.h"
 +#include "BKE_node.h"
 +#include "BKE_world.h"
 +#include "BKE_texture.h"
 +#include "BKE_utildefines.h"
 +
 +#include "IMB_imbuf.h"
 +#include "IMB_imbuf_types.h"
 +
 +#include "BIF_gl.h"
 +#include "BIF_glutil.h"
 +
 +#include "PIL_time.h"
 +
 +#include "RE_pipeline.h"
 +
 +#include "GPU_material.h"
 +
 +#include "WM_api.h"
 +#include "WM_types.h"
 +
 +#include "ED_anim_api.h"
 +#include "ED_previewrender.h"
 +#include "ED_view3d.h"
 +
 +#include "UI_interface.h"
 +
 +#include "previewrender_intern.h"
 +
 +#define PR_XMIN               10
 +#define PR_YMIN               5
 +#define PR_XMAX               200
 +#define PR_YMAX               195
 +
 +/* XXX */
 +static int qtest() {return 0;}
 +/* XXX */
 +
 +typedef struct ShaderPreview {
 +      /* from wmJob */
 +      void *owner;
 +      short *stop, *do_update;
 +      
 +      Scene *scene;
 +      ID *id;
 +      ID *parent;
 +      
 +      int sizex, sizey;
 +      int *pr_rect;
 +      int pr_method;
 +      
 +} ShaderPreview;
 +
 +
 +
 +/* unused now */
 +void draw_tex_crop(Tex *tex)
 +{
 +      rcti rct;
 +      int ret= 0;
 +      
 +      if(tex==0) return;
 +      
 +      if(tex->type==TEX_IMAGE) {
 +              if(tex->cropxmin==0.0f) ret++;
 +              if(tex->cropymin==0.0f) ret++;
 +              if(tex->cropxmax==1.0f) ret++;
 +              if(tex->cropymax==1.0f) ret++;
 +              if(ret==4) return;
 +              
 +              rct.xmin= PR_XMIN+2+tex->cropxmin*(PR_XMAX-PR_XMIN-4);
 +              rct.xmax= PR_XMIN+2+tex->cropxmax*(PR_XMAX-PR_XMIN-4);
 +              rct.ymin= PR_YMIN+2+tex->cropymin*(PR_YMAX-PR_YMIN-4);
 +              rct.ymax= PR_YMIN+2+tex->cropymax*(PR_YMAX-PR_YMIN-4);
 +
 +              glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
 +
 +              glColor3ub(0, 0, 0);
 +              glRecti(rct.xmin+1,  rct.ymin-1,  rct.xmax+1,  rct.ymax-1); 
 +
 +              glColor3ub(255, 255, 255);
 +              glRecti(rct.xmin,  rct.ymin,  rct.xmax,  rct.ymax);
 +
 +              glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);                      
 +      }
 +      
 +}
 +
 +/* temporal abuse; if id_code is -1 it only does texture.... solve! */
 +void BIF_preview_changed(short id_code)
 +{
 +#if 0 
 +      ScrArea *sa;
 +      
 +      for(sa= G.curscreen->areabase.first; sa; sa= sa->next) {
 +              if(sa->spacetype==SPACE_BUTS) {
 +                      SpaceButs *sbuts= sa->spacedata.first;
 +                      if(sbuts->mainb==CONTEXT_SHADING) {
 +                              int tab= sbuts->tab[CONTEXT_SHADING];
 +                              if(tab==TAB_SHADING_MAT && (id_code==ID_MA || id_code==ID_TE)) {
 +                                      if (sbuts->ri) sbuts->ri->curtile= 0;
 +                                      addafterqueue(sa->win, RENDERPREVIEW, 1);
 +                              }
 +                              else if(tab==TAB_SHADING_TEX && (id_code==ID_TE || id_code==-1)) {
 +                                      if (sbuts->ri) sbuts->ri->curtile= 0;
 +                                      addafterqueue(sa->win, RENDERPREVIEW, 1);
 +                              }
 +                              else if(tab==TAB_SHADING_LAMP && (id_code==ID_LA || id_code==ID_TE)) {
 +                                      if (sbuts->ri) sbuts->ri->curtile= 0;
 +                                      addafterqueue(sa->win, RENDERPREVIEW, 1);
 +                              }
 +                              else if(tab==TAB_SHADING_WORLD && (id_code==ID_WO || id_code==ID_TE)) {
 +                                      if (sbuts->ri) sbuts->ri->curtile= 0;
 +                                      addafterqueue(sa->win, RENDERPREVIEW, 1);
 +                              }
 +                      }
 +                      else if (sbuts->ri) 
 +                              sbuts->ri->curtile= 0;  /* ensure changes always result in re-render when context is restored */
 +              }
 +              else if(sa->spacetype==SPACE_NODE) {
 +                      SpaceNode *snode= sa->spacedata.first;
 +                      if(snode->treetype==NTREE_SHADER && (id_code==ID_MA || id_code==ID_TE)) {
 +                              snode_tag_dirty(snode);
 +                      }
 +              }
 +              else if(sa->spacetype==SPACE_VIEW3D) {
 +                      View3D *vd= sa->spacedata.first;
 +                      /* if is has a renderinfo, we consider that reason for signalling */
 +                      if (vd->ri) {
 +                              vd->ri->curtile= 0;
 +                              addafterqueue(sa->win, RENDERPREVIEW, 1);
 +                      }
 +              }
 +      }
 +
 +      if(ELEM4(id_code, ID_MA, ID_TE, ID_LA, ID_WO)) {
 +              Object *ob;
 +              Material *ma;
 +
 +              if(id_code == ID_WO) {
 +                      for(ma=G.main->mat.first; ma; ma=ma->id.next) {
 +                              if(ma->gpumaterial.first) {
 +                                      GPU_material_free(ma);
 +                              }
 +                      }
 +              }
 +              else if(id_code == ID_LA) {
 +                      for(ob=G.main->object.first; ob; ob=ob->id.next) {
 +                              if(ob->gpulamp.first) {
 +                                      GPU_lamp_free(ob);
 +                              }
 +                      }
 +
 +                      for(ma=G.main->mat.first; ma; ma=ma->id.next) {
 +                              if(ma->gpumaterial.first) {
 +                                      GPU_material_free(ma);
 +                              }
 +                      }
 +              } else if(OBACT) {
 +                      Object *ob = OBACT;
 +
 +                      ma= give_current_material(ob, ob->actcol);
 +                      if(ma && ma->gpumaterial.first) {
 +                              GPU_material_free(ma);
 +                      }
 +              }
 +      }
 +#endif
 +}
 +
 +/* *************************** Preview for buttons *********************** */
 +
 +static Main *pr_main= NULL;
 +
 +void ED_preview_init_dbase(void)
 +{
 +      BlendFileData *bfd;
 +      extern int datatoc_preview_blend_size;
 +      extern char datatoc_preview_blend[];
 +      
 +      G.fileflags |= G_FILE_NO_UI;
 +      bfd= BLO_read_from_memory(datatoc_preview_blend, datatoc_preview_blend_size, NULL);
 +      if (bfd) {
 +              pr_main= bfd->main;
 +              
 +              MEM_freeN(bfd);
 +      }
 +      G.fileflags &= ~G_FILE_NO_UI;
 +}
 +
 +void ED_preview_free_dbase(void)
 +{
 +      if(pr_main)
 +              free_main(pr_main);
 +}
 +
 +static Object *find_object(ListBase *lb, const char *name)
 +{
 +      Object *ob;
 +      for(ob= lb->first; ob; ob= ob->id.next)
 +              if(strcmp(ob->id.name+2, name)==0)
 +                      break;
 +      return ob;
 +}
 +
 +/* call this with a pointer to initialize preview scene */
 +/* call this with NULL to restore assigned ID pointers in preview scene */
 +static Scene *preview_prepare_scene(Scene *scene, ID *id, int id_type, ShaderPreview *sp)
 +{
 +      Scene *sce;
 +      Base *base;
 +      
 +      if(pr_main==NULL) return NULL;
 +      
 +      sce= pr_main->scene.first;
 +      if(sce) {
 +              /* this flag tells render to not execute depsgraph or ipos etc */
 +              sce->r.scemode |= R_PREVIEWBUTS;
 +              /* set world always back, is used now */
 +              sce->world= pr_main->world.first;
 +              /* now: exposure copy */
 +              if(scene->world) {
 +                      sce->world->exp= scene->world->exp;
 +                      sce->world->range= scene->world->range;
 +              }
 +              
 +              sce->r.color_mgt_flag = scene->r.color_mgt_flag;
 +              sce->r.cfra= scene->r.cfra;
 +              
 +              if(id_type==ID_MA) {
 +                      Material *mat= (Material *)id;
 +                      
 +                      if(id) {
 +                              init_render_material(mat, 0, NULL);             /* call that retrieves mode_l */
 +                              end_render_material(mat);
 +                              
 +                              /* turn on raytracing if needed */
 +                              if(mat->mode_l & (MA_RAYTRANSP|MA_RAYMIRROR))
 +                                      sce->r.mode |= R_RAYTRACE;
++                              if(mat->material_type == MA_TYPE_VOLUME)
++                                      sce->r.mode |= R_RAYTRACE;
 +                              if(mat->sss_flag & MA_DIFF_SSS)
 +                                      sce->r.mode |= R_SSS;
 +                              
 +                              /* turn off fake shadows if needed */
 +                              /* this only works in a specific case where the preview.blend contains
 +                               * an object starting with 'c' which has a material linked to it (not the obdata)
 +                               * and that material has a fake shadow texture in the active texture slot */
 +                              for(base= sce->base.first; base; base= base->next) {
 +                                      if(base->object->id.name[2]=='c') {
 +                                              Material *shadmat= give_current_material(base->object, base->object->actcol);
 +                                              if(shadmat) {
 +                                                      if (mat->mode & MA_SHADBUF) shadmat->septex = 0;
 +                                                      else shadmat->septex |= 1;
 +                                              }
 +                                      }
 +                              }
 +
 +                              
 +                              if(sp->pr_method==PR_ICON_RENDER) {
 +                                      if (mat->material_type == MA_TYPE_HALO) {
 +                                              sce->lay= 1<<MA_FLAT;
 +                                      } 
 +                                      else {
 +                                              sce->lay= 1<<MA_SPHERE_A;
 +                                      }
 +                              }
 +                              else {
 +                                      sce->lay= 1<<mat->pr_type;
 +                                      if(mat->nodetree)
 +                                              ntreeInitPreview(mat->nodetree, sp->sizex, sp->sizey);
 +                              }
 +                      }
 +                      else {
 +                              sce->r.mode &= ~(R_OSA|R_RAYTRACE|R_SSS);
 +                      }
 +                      
 +                      for(base= sce->base.first; base; base= base->next) {
 +                              if(base->object->id.name[2]=='p') {
 +                                      if(ELEM4(base->object->type, OB_MESH, OB_CURVE, OB_SURF, OB_MBALL))
 +                                              assign_material(base->object, mat, base->object->actcol);
 +                              }
 +                      }
 +              }
 +              else if(id_type==ID_TE) {
 +                      Tex *tex= (Tex *)id;
 +                      
 +                      sce->lay= 1<<MA_TEXTURE;
 +                      
 +                      /* exception: don't color manage texture previews */
 +                      sce->r.color_mgt_flag &= ~R_COLOR_MANAGEMENT;
 +                      
 +                      for(base= sce->base.first; base; base= base->next) {
 +                              if(base->object->id.name[2]=='t') {
 +                                      Material *mat= give_current_material(base->object, base->object->actcol);
 +                                      if(mat && mat->mtex[0]) {
 +                                              mat->mtex[0]->tex= tex;
 +                                              /* show alpha in this case */
 +                                              if(tex==NULL || (tex->flag & TEX_PRV_ALPHA)) {
 +                                                      mat->mtex[0]->mapto |= MAP_ALPHA;
 +                                                      mat->alpha= 0.0f;
 +                                              }
 +                                              else {
 +                                                      mat->mtex[0]->mapto &= ~MAP_ALPHA;
 +                                                      mat->alpha= 1.0f;
 +                                              }
 +                                      }
 +                              }
 +                      }
 +              }
 +              else if(id_type==ID_LA) {
 +                      Lamp *la= (Lamp *)id;
 +                      
 +                      if(la && la->type==LA_SUN && (la->sun_effect_type & LA_SUN_EFFECT_SKY)) {
 +                              sce->lay= 1<<MA_ATMOS;
 +                              sce->world= scene->world;
 +                              sce->camera= (Object *)find_object(&pr_main->object, "CameraAtmo");
 +                      }
 +                      else {
 +                              sce->lay= 1<<MA_LAMP;
 +                              sce->world= NULL;
 +                              sce->camera= (Object *)find_object(&pr_main->object, "Camera");
 +                      }
 +                      sce->r.mode &= ~R_SHADOW;
 +                      
 +                      for(base= sce->base.first; base; base= base->next) {
 +                              if(base->object->id.name[2]=='p') {
 +                                      if(base->object->type==OB_LAMP)
 +                                              base->object->data= la;
 +                              }
 +                      }
 +              }
 +              else if(id_type==ID_WO) {
 +                      sce->lay= 1<<MA_SKY;
 +                      sce->world= (World *)id;
 +              }
 +              
 +              return sce;
 +      }
 +      
 +      return NULL;
 +}
 +
 +/* new UI convention: draw is in pixel space already. */
 +/* uses ROUNDBOX button in block to get the rect */
 +static int ed_preview_draw_rect(ScrArea *sa, Scene *sce, ID *id, int split, int first, rcti *rect, rcti *newrect)
 +{
 +      RenderResult rres;
 +      char name[32];
 +      int gamma_correct=0;
 +      int offx=0, newx= rect->xmax-rect->xmin, newy= rect->ymax-rect->ymin;
 +
 +      if (id && GS(id->name) != ID_TE) {
 +              /* exception: don't color manage texture previews - show the raw values */
 +              if (sce) gamma_correct = sce->r.color_mgt_flag & R_COLOR_MANAGEMENT;
 +      }
 +
 +      if(!split || first) sprintf(name, "Preview %p", sa);
 +      else sprintf(name, "SecondPreview %p", sa);
 +
 +      if(split) {
 +              if(first) {
 +                      offx= 0;
 +                      newx= newx/2;
 +              }
 +              else {
 +                      offx= newx/2;
 +                      newx= newx - newx/2;
 +              }
 +      }
 +
 +      RE_GetResultImage(RE_GetRender(name), &rres);
 +
 +      if(rres.rectf) {
 +              
 +              if(ABS(rres.rectx-newx)<2 && ABS(rres.recty-newy)<2) {
 +                      newrect->xmax= MAX2(newrect->xmax, rect->xmin + rres.rectx + offx);
 +                      newrect->ymax= MAX2(newrect->ymax, rect->ymin + rres.recty);
 +
 +                      glPushMatrix();
 +                      glTranslatef(offx, 0, 0);
 +                      glaDrawPixelsSafe_to32(rect->xmin, rect->ymin, rres.rectx, rres.recty, rres.rectx, rres.rectf, gamma_correct);
 +                      glPopMatrix();
 +                      return 1;
 +              }
 +      }
 +
 +      return 0;
 +}
 +
 +void ED_preview_draw(const bContext *C, void *idp, void *parentp, rcti *rect)
 +{
 +      if(idp) {
 +              ScrArea *sa= CTX_wm_area(C);
 +              Scene *sce = CTX_data_scene(C);
 +              ID *id = (ID *)idp;
 +              ID *parent= (ID *)parentp;
 +              SpaceButs *sbuts= sa->spacedata.first;
 +              rcti newrect;
 +              int ok;
 +              int newx= rect->xmax-rect->xmin, newy= rect->ymax-rect->ymin;
 +
 +              newrect.xmin= rect->xmin;
 +              newrect.xmax= rect->xmin;
 +              newrect.ymin= rect->ymin;
 +              newrect.ymax= rect->ymin;
 +
 +              if(parent) {
 +                      ok = ed_preview_draw_rect(sa, sce, parent, 1, 1, rect, &newrect);
 +                      ok &= ed_preview_draw_rect(sa, sce, id, 1, 0, rect, &newrect);
 +              }
 +              else
 +                      ok = ed_preview_draw_rect(sa, sce, id, 0, 0, rect, &newrect);
 +
 +              if(ok)
 +                      *rect= newrect;
 +
 +              /* check for spacetype... */
 +              if(sbuts->spacetype==SPACE_BUTS && sbuts->preview) {
 +                      sbuts->preview= 0;
 +                      ok= 0;
 +              }
 +              
 +              if(ok==0) {
 +                      ED_preview_shader_job(C, sa, id, parent, newx, newy);
 +              }
 +      }       
 +}
 +
 +/* *************************** Preview for 3d window *********************** */
 +
 +void view3d_previewrender_progress(RenderResult *rr, volatile rcti *renrect)
 +{
 +//    ScrArea *sa= NULL; // XXX
 +//    View3D *v3d= NULL; // XXX
 +      RenderLayer *rl;
 +      int ofsx=0, ofsy=0;
 +      
 +      if(renrect) return;
 +      
 +      rl= rr->layers.first;
 +      
 +      /* this case is when we render envmaps... */
 +//    if(rr->rectx > v3d->ri->pr_rectx || rr->recty > v3d->ri->pr_recty)
 +//            return;
 +      
 +//    ofsx= v3d->ri->disprect.xmin + rr->tilerect.xmin;
 +//    ofsy= v3d->ri->disprect.ymin + rr->tilerect.ymin;
 +      
 +      glDrawBuffer(GL_FRONT);
 +//    glaDefine2DArea(&sa->winrct);
 +      glaDrawPixelsSafe_to32(ofsx, ofsy, rr->rectx, rr->recty, rr->rectx, rl->rectf, 0);
 +      bglFlush();
 +      glDrawBuffer(GL_BACK);
 +
 +}
 +
 +void BIF_view3d_previewrender_signal(ScrArea *sa, short signal)
 +{
 +#if 0
 +      View3D *v3d= sa->spacedata.first;
 +      
 +      /* this can be called from other window... solve! */
 +      if(sa->spacetype!=SPACE_VIEW3D)
 +              return; // XXX
 +         
 +      if(v3d && v3d->ri) {
 +              RenderInfo *ri= v3d->ri;
 +              ri->status &= ~signal;
 +              ri->curtile= 0;
 +              //printf("preview signal %d\n", signal);
 +              if(ri->re && (signal & PR_DBASE))
 +                      RE_Database_Free(ri->re);
 +
 +//            addafterqueue(sa->win, RENDERPREVIEW, 1);
 +      }
 +#endif
 +}
 +
 +void BIF_view3d_previewrender_free(View3D *v3d)
 +{
 +#if 0
 +      if(v3d->ri) {
 +              RenderInfo *ri= v3d->ri;
 +              if(ri->re) {
 +//                    printf("free render\n");
 +                      RE_Database_Free(ri->re);
 +                      RE_FreeRender(ri->re);
 +                      ri->re= NULL;
 +              }
 +              if (v3d->ri->rect) MEM_freeN(v3d->ri->rect);
 +              MEM_freeN(v3d->ri);
 +              v3d->ri= NULL;
 +      }
 +#endif
 +}
 +
 +/* returns 1 if OK, do not call while in panel space!  */
 +static int view3d_previewrender_get_rects(ScrArea *sa, rctf *viewplane, RenderInfo *ri, float *clipsta, float *clipend, int *ortho, float *pixsize)
 +{
 +      View3D *v3d= NULL; // XXX
 +      RegionView3D *rv3d= NULL; // XXX
 +      int rectx, recty;
 +//    uiBlock *block;
 +      
 +//    block= uiFindOpenPanelBlockName(&sa->uiblocks, "Preview");
 +//    if(block==NULL) return 0;
 +      
 +      /* calculate preview rect size */
 +//    BLI_init_rctf(viewplane, 15.0f, (block->maxx - block->minx)-15.0f, 15.0f, (block->maxy - block->miny)-15.0f);
 +//    uiPanelPush(block);
 +//    ui_graphics_to_window_rct(sa->win, viewplane, &ri->disprect);
 +//    uiPanelPop(block);
 +      
 +      /* correction for gla draw */
 +//    BLI_translate_rcti(&ri->disprect, -sa->winrct.xmin, -sa->winrct.ymin);
 +      
 +      *ortho= get_view3d_viewplane(v3d, rv3d, sa->winx, sa->winy, viewplane, clipsta, clipend, pixsize);
 +
 +      rectx= ri->disprect.xmax - ri->disprect.xmin;
 +      recty= ri->disprect.ymax - ri->disprect.ymin;
 +      
 +      if(rectx<4 || recty<4) return 0;
 +      
 +      if(ri->rect && (rectx!=ri->pr_rectx || recty!=ri->pr_recty)) {
 +              MEM_freeN(ri->rect);
 +              ri->rect= NULL;
 +              ri->curtile= 0;
 +              printf("changed size\n");
 +      }
 +      ri->pr_rectx= rectx;
 +      ri->pr_recty= recty;
 +      
 +      return 1;
 +}
 +
 +/* called before a panel gets moved/scaled, makes sure we can see through */
 +void BIF_view3d_previewrender_clear(ScrArea *sa)
 +{
 +#if 0
 +      View3D *v3d= sa->spacedata.first;
 +
 +      if(v3d->ri) {
 +              RenderInfo *ri= v3d->ri;
 +              ri->curtile= 0;
 +              if(ri->rect)
 +                      MEM_freeN(ri->rect);
 +              ri->rect= NULL;
 +      }
 +#endif
 +}
 +
 +/* afterqueue call */
 +void BIF_view3d_previewrender(Scene *scene, ScrArea *sa)
 +{
 +      bContext *C= NULL;
 +      View3D *v3d= sa->spacedata.first;
 +      RegionView3D *rv3d= NULL; // XXX
 +      Render *re;
 +      RenderInfo *ri=NULL;    /* preview struct! */
 +      RenderStats *rstats;
 +      RenderData rdata;
 +      rctf viewplane;
 +      float clipsta, clipend, pixsize;
 +      int orth;
 +      
 +      /* first get the render info right */
 +//    if (!v3d->ri) {
 +//            ri= v3d->ri= MEM_callocN(sizeof(RenderInfo), "butsrenderinfo");
 +//            ri->tottile= 10000;
 +//    }
 +//    ri= v3d->ri;
 +      
 +      if(0==view3d_previewrender_get_rects(sa, &viewplane, ri, &clipsta, &clipend, &orth, &pixsize))
 +              return;
 +      
 +      /* render is finished, so return */
 +      if(ri->tottile && ri->curtile>=ri->tottile) return;
 +
 +      /* or return with a new event */
 +      if(qtest()) {
 +//            addafterqueue(sa->win, RENDERPREVIEW, 1);
 +              return;
 +      }
 +      //printf("Enter previewrender\n");
 +      /* ok, are we rendering all over? */
 +      if(ri->re==NULL) {
 +              char name[32];
 +              
 +              ri->status= 0;
 +              
 +              sprintf(name, "View3dPreview %p", sa);
 +              re= ri->re= RE_NewRender(name);
 +              //RE_display_draw_cb(re, view3d_previewrender_progress);
 +              //RE_stats_draw_cb(re, view3d_previewrender_stats);
 +              //RE_test_break_cb(re, qtest);
 +              
 +              /* no osa, blur, seq, layers, etc for preview render */
 +              rdata= scene->r;
 +              rdata.mode &= ~(R_OSA|R_MBLUR);
 +              rdata.scemode &= ~(R_DOSEQ|R_DOCOMP|R_FREE_IMAGE);
 +              rdata.layers.first= rdata.layers.last= NULL;
 +              rdata.renderer= R_INTERN;
 +               
 +              RE_InitState(re, NULL, &rdata, sa->winx, sa->winy, &ri->disprect);
 +      
 +              if(orth)
 +                      RE_SetOrtho(re, &viewplane, clipsta, clipend);
 +              else
 +                      RE_SetWindow(re, &viewplane, clipsta, clipend);
 +              RE_SetPixelSize(re, pixsize);
 +              
 +              /* until here are no escapes */
 +              ri->status |= PR_DISPRECT;
 +              ri->curtile= 0;
 +              //printf("new render\n");
 +      }
 +
 +      re= ri->re;
 +      
 +      PIL_sleep_ms(100);      /* wait 0.1 second if theres really no event... */
 +      if(qtest()==0)  {
 +              
 +              /* check status */
 +              if((ri->status & PR_DISPRECT)==0) {
 +                      RE_SetDispRect(ri->re, &ri->disprect);
 +                      if(orth)
 +                              RE_SetOrtho(ri->re, &viewplane, clipsta, clipend);
 +                      else
 +                              RE_SetWindow(ri->re, &viewplane, clipsta, clipend);
 +                      RE_SetPixelSize(re, pixsize);
 +                      ri->status |= PR_DISPRECT;
 +                      ri->curtile= 0;
 +                      //printf("disprect update\n");
 +              }
 +              if((ri->status & PR_DBASE)==0) {
 +                      unsigned int lay= scene->lay;
 +                      
 +                      RE_SetView(re, rv3d->viewmat);
 +                      
 +                      /* allow localview render for objects with lights in normal layers */
 +                      if(v3d->lay & 0xFF000000)
 +                              scene->lay |= v3d->lay;
 +                      else scene->lay= v3d->lay;
 +                      
 +                      RE_Database_FromScene(re, scene, 0);            // 0= dont use camera view
 +                      scene->lay= lay;
 +                      
 +                      rstats= RE_GetStats(re);
 +                      if(rstats->convertdone) 
 +                              ri->status |= PR_DBASE|PR_PROJECTED|PR_ROTATED;
 +                      ri->curtile= 0;
 +                      
 +                      /* database can have created render-resol data... */
 +                      if(rstats->convertdone) 
 +                              ED_anim_dag_flush_update(C); // <--- only current scene XXX
 +                      
 +                      //printf("dbase update\n");
 +              }
 +              if((ri->status & PR_PROJECTED)==0) {
 +                      if(ri->status & PR_DBASE) {
 +                              if(orth)
 +                                      RE_SetOrtho(ri->re, &viewplane, clipsta, clipend);
 +                              else
 +                                      RE_SetWindow(ri->re, &viewplane, clipsta, clipend);
 +                              RE_DataBase_ApplyWindow(re);
 +                              ri->status |= PR_PROJECTED;
 +                      }
 +                      ri->curtile= 0;
 +                      //printf("project update\n");
 +              }
 +      
 +              /* OK, can we enter render code? */
 +              if(ri->status==(PR_DISPRECT|PR_DBASE|PR_PROJECTED|PR_ROTATED)) {
 +                      //printf("curtile %d tottile %d\n", ri->curtile, ri->tottile);
 +                      RE_TileProcessor(ri->re, ri->curtile, 0);
 +      
 +                      if(ri->rect==NULL)
 +                              ri->rect= MEM_mallocN(sizeof(int)*ri->pr_rectx*ri->pr_recty, "preview view3d rect");
 +                      
 +                      RE_ResultGet32(ri->re, ri->rect);
 +              }
 +              
 +              rstats= RE_GetStats(ri->re);
 +//            if(rstats->totpart==rstats->partsdone && rstats->partsdone)
 +//                    addqueue(sa->win, REDRAW, 1);
 +//            else
 +//                    addafterqueue(sa->win, RENDERPREVIEW, 1);
 +              
 +              ri->curtile= rstats->partsdone;
 +              ri->tottile= rstats->totpart;
 +      }
 +      else {
 +//            addafterqueue(sa->win, RENDERPREVIEW, 1);
 +      }
 +      
 +      //printf("\n");
 +}
 +
 +/* in panel space! */
 +static void view3d_previewdraw_rect(ScrArea *sa, uiBlock *block, RenderInfo *ri)
 +{
 +//    rctf dispf;
 +      
 +      if(ri->rect==NULL)
 +              return;
 +      
 +//    BLI_init_rctf(&dispf, 15.0f, (block->maxx - block->minx)-15.0f, 15.0f, (block->maxy - block->miny)-15.0f);
 +//    ui_graphics_to_window_rct(sa->win, &dispf, &ri->disprect);
 +
 +      /* correction for gla draw */
 +//    BLI_translate_rcti(&ri->disprect, -sa->winrct.xmin, -sa->winrct.ymin);
 +      
 +      /* when panel scale changed, free rect */
 +      if(ri->disprect.xmax-ri->disprect.xmin != ri->pr_rectx ||
 +         ri->disprect.ymax-ri->disprect.ymin != ri->pr_recty) {
 +              MEM_freeN(ri->rect);
 +              ri->rect= NULL;
 +      }
 +      else {
 +//            glaDefine2DArea(&sa->winrct);
 +              glaDrawPixelsSafe(ri->disprect.xmin, ri->disprect.ymin, ri->pr_rectx, ri->pr_recty, ri->pr_rectx, GL_RGBA, GL_UNSIGNED_BYTE, ri->rect);
 +      }       
 +}
 +
 +/* is panel callback, supposed to be called with correct panel offset matrix */
 +void BIF_view3d_previewdraw(struct ScrArea *sa, struct uiBlock *block)
 +{
 +      RegionView3D *rv3d= NULL;
 +
 +//    if (v3d->ri==NULL || v3d->ri->rect==NULL) 
 +//            addafterqueue(sa->win, RENDERPREVIEW, 1);
 +//    else {
 +              view3d_previewdraw_rect(sa, block, rv3d->ri);
 +//            if(v3d->ri->curtile==0) 
 +//                    addafterqueue(sa->win, RENDERPREVIEW, 1);
 +//    }
 +}
 +
 +
 +/* **************************** New preview system ****************** */
 +
 +/* inside thread, called by renderer, sets job update value */
 +static void shader_preview_draw(void *spv, RenderResult *rr, volatile struct rcti *rect)
 +{
 +      ShaderPreview *sp= spv;
 +      
 +      *(sp->do_update)= 1;
 +}
 +
 +/* called by renderer, checks job value */
 +static int shader_preview_break(void *spv)
 +{
 +      ShaderPreview *sp= spv;
 +      
 +      return *(sp->stop);
 +}
 +
 +/* outside thread, called before redraw notifiers, it moves finished preview over */
 +static void shader_preview_updatejob(void *spv)
 +{
 +//    ShaderPreview *sp= spv;
 +      
 +}
 +
 +static void shader_preview_render(ShaderPreview *sp, ID *id, int split, int first)
 +{
 +      Render *re;
 +      Scene *sce;
 +      float oldlens;
 +      char name[32];
 +      int sizex;
 +
 +      /* get the stuff from the builtin preview dbase */
 +      sce= preview_prepare_scene(sp->scene, id, GS(id->name), sp); // XXX sizex
 +      if(sce==NULL) return;
 +      
 +      if(!split || first) sprintf(name, "Preview %p", sp->owner);
 +      else sprintf(name, "SecondPreview %p", sp->owner);
 +      re= RE_GetRender(name);
 +      
 +      /* full refreshed render from first tile */
 +      if(re==NULL)
 +              re= RE_NewRender(name);
 +              
 +      /* sce->r gets copied in RE_InitState! */
 +      if(sp->pr_method==PR_DO_RENDER) {
 +              sce->r.scemode |= R_NODE_PREVIEW;
 +              sce->r.scemode &= ~R_NO_IMAGE_LOAD;
 +              sce->r.mode |= R_OSA;
 +      }
 +      else {  /* PR_ICON_RENDER */
 +              sce->r.scemode &= ~R_NODE_PREVIEW;
 +              sce->r.scemode |= R_NO_IMAGE_LOAD;
 +      }
 +
 +      /* in case of split preview, use border render */
 +      if(split) {
 +              if(first) sizex= sp->sizex/2;
 +              else sizex= sp->sizex - sp->sizex/2;
 +      }
 +      else sizex= sp->sizex;
 +
 +      /* allocates or re-uses render result */
 +      RE_InitState(re, NULL, &sce->r, sizex, sp->sizey, NULL);
 +
 +      /* callbacs are cleared on GetRender() */
 +      if(sp->pr_method==PR_DO_RENDER) {
 +              RE_display_draw_cb(re, sp, shader_preview_draw);
 +              RE_test_break_cb(re, sp, shader_preview_break);
 +      }
 +      /* lens adjust */
 +      oldlens= ((Camera *)sce->camera->data)->lens;
 +      if(sizex > sp->sizey)
 +              ((Camera *)sce->camera->data)->lens *= (float)sp->sizey/(float)sizex;
 +
 +      /* entire cycle for render engine */
 +      RE_SetCamera(re, sce->camera);
 +      RE_Database_FromScene(re, sce, 1);
 +      RE_TileProcessor(re, 0, 1);     // actual render engine
 +      RE_Database_Free(re);
 +
 +      ((Camera *)sce->camera->data)->lens= oldlens;
 +
 +      /* handle results */
 +      if(sp->pr_method==PR_ICON_RENDER) {
 +              if(sp->pr_rect)
 +                      RE_ResultGet32(re, (unsigned int *)sp->pr_rect);
 +      }
 +      else {
 +              /* validate owner */
 +              //if(ri->rect==NULL)
 +              //      ri->rect= MEM_mallocN(sizeof(int)*ri->pr_rectx*ri->pr_recty, "BIF_previewrender");
 +              //RE_ResultGet32(re, ri->rect);
 +      }
 +
 +      /* unassign the pointers, reset vars */
 +      preview_prepare_scene(sp->scene, NULL, GS(id->name), NULL);
 +}
 +
 +/* runs inside thread for material, in foreground for icons */
 +static void shader_preview_startjob(void *customdata, short *stop, short *do_update)
 +{
 +      ShaderPreview *sp= customdata;
 +
 +      sp->stop= stop;
 +      sp->do_update= do_update;
 +
 +      if(sp->parent) {
 +              shader_preview_render(sp, sp->parent, 1, 1);
 +              shader_preview_render(sp, sp->id, 1, 0);
 +      }
 +      else
 +              shader_preview_render(sp, sp->id, 0, 0);
 +
 +      *do_update= 1;
 +}
 +
 +static void shader_preview_free(void *customdata)
 +{
 +      ShaderPreview *sp= customdata;
 +      
 +      MEM_freeN(sp);
 +}
 +
 +void ED_preview_shader_job(const bContext *C, void *owner, ID *id, ID *parent, int sizex, int sizey)
 +{
 +      wmJob *steve;
 +      ShaderPreview *sp;
 +
 +      /* XXX ugly global still, but we can't do preview while rendering */
 +      if(G.rendering)
 +              return;
 +
 +      steve= WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), owner);
 +      sp= MEM_callocN(sizeof(ShaderPreview), "shader preview");
 +
 +      /* customdata for preview thread */
 +      sp->scene= CTX_data_scene(C);
 +      sp->owner= owner;
 +      sp->sizex= sizex;
 +      sp->sizey= sizey;
 +      sp->pr_method= PR_DO_RENDER;
 +      sp->id = id;
 +      sp->parent= parent;
 +      
 +      /* setup job */
 +      WM_jobs_customdata(steve, sp, shader_preview_free);
 +      WM_jobs_timer(steve, 0.1, NC_MATERIAL, NC_MATERIAL);
 +      WM_jobs_callbacks(steve, shader_preview_startjob, NULL, shader_preview_updatejob);
 +      
 +      WM_jobs_start(CTX_wm_manager(C), steve);
 +      
 +      /* signal to rerender icon in menus */
 +      BKE_icon_changed(BKE_icon_getid(id));
 +}
 +
 +/* rect should be allocated, sizex/sizy pixels, 32 bits */
 +void ED_preview_iconrender(Scene *scene, ID *id, unsigned int *rect, int sizex, int sizey)
 +{
 +      ShaderPreview *sp;
 +      short stop=0, do_update=0;
 +
 +      sp= MEM_callocN(sizeof(ShaderPreview), "ShaderPreview");
 +      
 +      /* customdata for preview thread */
 +      sp->scene= scene;
 +      sp->sizex= sizex;
 +      sp->sizey= sizey;
 +      sp->pr_method= PR_ICON_RENDER;
 +      sp->pr_rect= (int *)rect; /* shouldnt pr_rect be unsigned int also? - Campbell */
 +      sp->id = id;
 +
 +      shader_preview_startjob(sp, &stop, &do_update);
 +      
 +      MEM_freeN(sp);
 +}
 +
 +
 +
index 8428e750025bd7554a8577777b8652503476c7c3,dafa816cb968ad71ae5fcfd1747ae6a9e546589f..22ec0f6d59ea04cc95f75cb201e553d0440b8161
@@@ -47,11 -48,10 +47,30 @@@ struct Ipo
  
  /* WATCH IT: change type? also make changes in ipo.h  */
  
++typedef struct VolumeSettings {
++      short stepsize_type;
++      short precache_resolution;
++      float stepsize, shade_stepsize;
++      float depth_cutoff;
++      short shade_type;
++      short vpad;
++      float density_scale;
++      float absorption, scattering;
++      float absorption_col[3];
++      short shadeflag;
++      short phasefunc_type;
++      float phasefunc_g;
++      float vpad2[2];
++      
++      float ms_diff, ms_intensity;
++      int ms_steps;
++} VolumeSettings;
++
  typedef struct Material {
        ID id;
 +      struct AnimData *adt;   /* animation data (must be immediately after id for utilities to use it) */ 
        
 -      short colormodel, flag; 
 +      short material_type, flag;      
        /* note, keep this below synced with render_types.h */
        float r, g, b;
        float specr, specg, specb;
        float translucency;
        /* end synced with render_types.h */
        
 -      short material_type; /* solid, halo, volumetric */
 -      short pad5;
 -      
 -      /* volumetrics */
 -      short vol_stepsize_type;
 -      short vol_precache_resolution;
 -      float vol_stepsize, vol_shade_stepsize;
 -      float vol_depth_cutoff;
 -      short vol_shade_type;
 -      short vpad;
 -      float vol_density_scale;
 -      float vol_absorption, vol_scattering;
 -      float vol_absorption_col[3];
 -      short vol_shadeflag;
 -      short vol_phasefunc_type;
 -      float vol_phasefunc_g;
 -      float vpad2;
 -      
 -      float vol_ms_diff, vol_ms_intensity;
 -      int vol_ms_steps;
 -              
++      struct VolumeSettings vol;
++
        float fresnel_mir, fresnel_mir_i;
        float fresnel_tra, fresnel_tra_i;
        float filter;           /* filter added, for raytrace transparency and transmissivity */
index 7367ee3cf71525b27c62a5725b8044a43a130979,5cbad6cf4247be3382b274aa29b486ac12edd7bb..820d3309b136837c3fc9268b47b6f03a2ab56107
@@@ -128,9 -127,57 +128,59 @@@ typedef struct EnvMap 
        short recalc, lastsize;
  } EnvMap;
  
 -      int resolX, resolY, resolZ;
+ typedef struct PointDensity {
+       short flag;
+       short falloff_type;
+       float falloff_softness;
+       float radius;
+       short source;
+       short color_source;
+       int totpoints;
+       
+       int pdpad;
+       struct Object *object;  /* for 'Object' or 'Particle system' type - source object */
+       short psys_cache_space;         /* cache points in worldspace, object space, ... ? */
+       short psysindex;                /* for 'Particle system' type - object's psys number */
+       
+       short ob_cache_space;           /* cache points in worldspace, object space, ... ? */
+       
+       short pdpad2;
+       
+       void *point_tree;               /* the acceleration tree containing points */
+       float *point_data;              /* dynamically allocated extra for extra information, like particle age */
+       
+       float noise_size;
+       short noise_depth;
+       short noise_influence;
+       short noise_basis;
+     short pdpad3[3];
+       float noise_fac;
+       
+       float speed_scale;
+       struct ColorBand *coba; /* for time -> color */
+       
+ } PointDensity;
+ typedef struct VoxelData {
 -      float int_multiplier;
 -      
 -      int still, still_frame;
++      int resol[3];
+       int interp_type;
+       short file_format;
+       short flag;
++      int pad;
+       
++      struct Object *object; /* for rendering smoke sims */
++      float int_multiplier;   
++      int still_frame;
+       char source_path[240];
+       float *dataset;
+  
+ } VoxelData;
  typedef struct Tex {
        ID id;
 +      struct AnimData *adt;   /* animation data (must be immediately after id for utilities to use it) */ 
        
        float noisesize, turbul;
        float bright, contrast, rfac, gfac, bfac;
@@@ -220,6 -263,9 +272,8 @@@ typedef struct TexMapping 
  #define TEX_MUSGRAVE  11
  #define TEX_VORONOI           12
  #define TEX_DISTNOISE 13
 -/* predicting ocean texture for 14 */
 -#define TEX_POINTDENSITY      15
 -#define TEX_VOXELDATA         16
++#define TEX_POINTDENSITY      14
++#define TEX_VOXELDATA         15
  
  /* musgrave stype */
  #define TEX_MFRACTAL          0
  #define ENV_NORMAL    1
  #define ENV_OSA               2
  
 -
+ /* **************** PointDensity ********************* */
+ /* source */
+ #define TEX_PD_PSYS                   0
+ #define TEX_PD_OBJECT         1
+ #define TEX_PD_FILE                   2
+ /* falloff_type */
+ #define TEX_PD_FALLOFF_STD            0
+ #define TEX_PD_FALLOFF_SMOOTH 1
+ #define TEX_PD_FALLOFF_SOFT           2
+ #define TEX_PD_FALLOFF_CONSTANT       3
+ #define TEX_PD_FALLOFF_ROOT           4
+ /* psys_cache_space */
+ #define TEX_PD_OBJECTLOC      0
+ #define TEX_PD_OBJECTSPACE    1
+ #define TEX_PD_WORLDSPACE     2
+ /* flag */
+ #define TEX_PD_TURBULENCE     1
+ /* noise_influence */
+ #define TEX_PD_NOISE_STATIC           0
+ #define TEX_PD_NOISE_VEL              1
+ #define TEX_PD_NOISE_AGE              2
+ #define TEX_PD_NOISE_TIME             3
+ /* color_source */
+ #define TEX_PD_COLOR_CONSTANT 0
+ #define TEX_PD_COLOR_PARTAGE  1
+ #define TEX_PD_COLOR_PARTSPEED        2
+ #define TEX_PD_COLOR_PARTVEL  3
+ #define POINT_DATA_VEL                1
+ #define POINT_DATA_LIFE               2
+ /******************** Voxel Data *****************************/
+ /* flag */
++#define TEX_VD_STILL                  1
+ /* interpolation */
+ #define TEX_VD_NEARESTNEIGHBOR                0
+ #define TEX_VD_LINEAR                         1
+ #define TEX_VD_TRICUBIC                               2
+ /* file format */
+ #define TEX_VD_BLENDERVOXEL           0
+ #define TEX_VD_RAW_8BIT                       1
+ #define TEX_VD_RAW_16BIT              2
+ #define TEX_VD_IMAGE_SEQUENCE 3
++#define TEX_VD_SMOKE                  4
  #endif
  
index 06752250bd04e98a05724a0a810ab66d9e2372fc,0000000000000000000000000000000000000000..632413e11bfa7719bfd7f0c990d1e29715682cbe
mode 100644,000000..100644
--- /dev/null
@@@ -1,815 -1,0 +1,819 @@@
 +/**
 + * $Id$
 + *
 + * ***** BEGIN GPL 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.
 + *
 + * 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.
 + *
 + * Contributor(s): Blender Foundation (2008).
 + *
 + * ***** END GPL LICENSE BLOCK *****
 + */
 +
 +#ifndef RNA_ACCESS
 +#define RNA_ACCESS
 +
 +#include <stdarg.h>
 +
 +#include "DNA_listBase.h"
 +#include "RNA_types.h"
 +
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +struct bContext;
 +struct ID;
 +struct Main;
 +struct ReportList;
 +
 +/* Types */
 +
 +extern BlenderRNA BLENDER_RNA;
 +
 +extern StructRNA RNA_Action;
 +extern StructRNA RNA_ActionConstraint;
 +extern StructRNA RNA_ActionGroup;
 +extern StructRNA RNA_Actuator;
 +extern StructRNA RNA_ActuatorSensor;
 +extern StructRNA RNA_AlwaysSensor;
 +extern StructRNA RNA_AndController;
 +extern StructRNA RNA_AnimData;
 +extern StructRNA RNA_AnyType;
 +extern StructRNA RNA_Area;
 +extern StructRNA RNA_AreaLamp;
 +extern StructRNA RNA_Armature;
 +extern StructRNA RNA_ArmatureModifier;
 +extern StructRNA RNA_ArrayModifier;
 +extern StructRNA RNA_BackgroundImage;
 +extern StructRNA RNA_BevelModifier;
 +extern StructRNA RNA_BezierCurvePoint;
 +extern StructRNA RNA_BlendTexture;
 +extern StructRNA RNA_BlenderRNA;
 +extern StructRNA RNA_BoidRule;
 +extern StructRNA RNA_BoidRuleAverageSpeed;
 +extern StructRNA RNA_BoidRuleAvoid;
 +extern StructRNA RNA_BoidRuleAvoidCollision;
 +extern StructRNA RNA_BoidRuleFight;
 +extern StructRNA RNA_BoidRuleFollowLeader;
 +extern StructRNA RNA_BoidRuleGoal;
 +extern StructRNA RNA_BoidSettings;
 +extern StructRNA RNA_BoidState;
 +extern StructRNA RNA_Bone;
 +extern StructRNA RNA_BoneGroup;
 +extern StructRNA RNA_BooleanModifier;
 +extern StructRNA RNA_BooleanProperty;
 +extern StructRNA RNA_Brush;
 +extern StructRNA RNA_BuildModifier;
 +extern StructRNA RNA_Camera;
 +extern StructRNA RNA_CastModifier;
 +extern StructRNA RNA_ChildOfConstraint;
 +extern StructRNA RNA_ChildParticle;
 +extern StructRNA RNA_ClampToConstraint;
 +extern StructRNA RNA_ClothCollisionSettings;
 +extern StructRNA RNA_ClothModifier;
 +extern StructRNA RNA_ClothSettings;
 +extern StructRNA RNA_CloudsTexture;
 +extern StructRNA RNA_CollectionProperty;
 +extern StructRNA RNA_CollisionModifier;
 +extern StructRNA RNA_CollisionSensor;
 +extern StructRNA RNA_CollisionSettings;
 +extern StructRNA RNA_ColorRamp;
 +extern StructRNA RNA_ColorRampElement;
 +extern StructRNA RNA_ColorSequence;
 +extern StructRNA RNA_CompositorNode;
 +extern StructRNA RNA_CompositorNodeAlphaOver;
 +extern StructRNA RNA_CompositorNodeBilateralblur;
 +extern StructRNA RNA_CompositorNodeBlur;
 +extern StructRNA RNA_CompositorNodeBrightContrast;
 +extern StructRNA RNA_CompositorNodeChannelMatte;
 +extern StructRNA RNA_CompositorNodeChroma;
 +extern StructRNA RNA_CompositorNodeColorSpill;
 +extern StructRNA RNA_CompositorNodeCombHSVA;
 +extern StructRNA RNA_CompositorNodeCombRGBA;
 +extern StructRNA RNA_CompositorNodeCombYCCA;
 +extern StructRNA RNA_CompositorNodeCombYUVA;
 +extern StructRNA RNA_CompositorNodeComposite;
 +extern StructRNA RNA_CompositorNodeCrop;
 +extern StructRNA RNA_CompositorNodeCurveRGB;
 +extern StructRNA RNA_CompositorNodeCurveVec;
 +extern StructRNA RNA_CompositorNodeDBlur;
 +extern StructRNA RNA_CompositorNodeDefocus;
 +extern StructRNA RNA_CompositorNodeDiffMatte;
 +extern StructRNA RNA_CompositorNodeDilateErode;
 +extern StructRNA RNA_CompositorNodeDisplace;
 +extern StructRNA RNA_CompositorNodeFilter;
 +extern StructRNA RNA_CompositorNodeFlip;
 +extern StructRNA RNA_CompositorNodeGamma;
 +extern StructRNA RNA_CompositorNodeGlare;
 +extern StructRNA RNA_CompositorNodeHueSat;
 +extern StructRNA RNA_CompositorNodeIDMask;
 +extern StructRNA RNA_CompositorNodeImage;
 +extern StructRNA RNA_CompositorNodeInvert;
 +extern StructRNA RNA_CompositorNodeLensdist;
 +extern StructRNA RNA_CompositorNodeLumaMatte;
 +extern StructRNA RNA_CompositorNodeMapUV;
 +extern StructRNA RNA_CompositorNodeMapValue;
 +extern StructRNA RNA_CompositorNodeMath;
 +extern StructRNA RNA_CompositorNodeMixRGB;
 +extern StructRNA RNA_CompositorNodeNormal;
 +extern StructRNA RNA_CompositorNodeNormalize;
 +extern StructRNA RNA_CompositorNodeOutputFile;
 +extern StructRNA RNA_CompositorNodePremulKey;
 +extern StructRNA RNA_CompositorNodeRGB;
 +extern StructRNA RNA_CompositorNodeRGBToBW;
 +extern StructRNA RNA_CompositorNodeRLayers;
 +extern StructRNA RNA_CompositorNodeRotate;
 +extern StructRNA RNA_CompositorNodeScale;
 +extern StructRNA RNA_CompositorNodeSepHSVA;
 +extern StructRNA RNA_CompositorNodeSepRGBA;
 +extern StructRNA RNA_CompositorNodeSepYCCA;
 +extern StructRNA RNA_CompositorNodeSepYUVA;
 +extern StructRNA RNA_CompositorNodeSetAlpha;
 +extern StructRNA RNA_CompositorNodeSplitViewer;
 +extern StructRNA RNA_CompositorNodeTexture;
 +extern StructRNA RNA_CompositorNodeTime;
 +extern StructRNA RNA_CompositorNodeTonemap;
 +extern StructRNA RNA_CompositorNodeTranslate;
 +extern StructRNA RNA_CompositorNodeValToRGB;
 +extern StructRNA RNA_CompositorNodeValue;
 +extern StructRNA RNA_CompositorNodeVecBlur;
 +extern StructRNA RNA_CompositorNodeViewer;
 +extern StructRNA RNA_CompositorNodeZcombine;
 +extern StructRNA RNA_ConsoleLine;
 +extern StructRNA RNA_Constraint;
 +extern StructRNA RNA_ConstraintTarget;
 +extern StructRNA RNA_Context;
 +extern StructRNA RNA_ControlFluidSettings;
 +extern StructRNA RNA_Controller;
 +extern StructRNA RNA_CopyLocationConstraint;
 +extern StructRNA RNA_CopyRotationConstraint;
 +extern StructRNA RNA_CopyScaleConstraint;
 +extern StructRNA RNA_Curve;
 +extern StructRNA RNA_CurveMap;
 +extern StructRNA RNA_CurveMapPoint;
 +extern StructRNA RNA_CurveMapping;
 +extern StructRNA RNA_CurveModifier;
 +extern StructRNA RNA_CurvePoint;
 +extern StructRNA RNA_DecimateModifier;
 +extern StructRNA RNA_DelaySensor;
 +extern StructRNA RNA_DisplaceModifier;
 +extern StructRNA RNA_DistortedNoiseTexture;
 +extern StructRNA RNA_DomainFluidSettings;
 +extern StructRNA RNA_Driver;
 +extern StructRNA RNA_DriverTarget;
 +extern StructRNA RNA_EdgeSplitModifier;
 +extern StructRNA RNA_EditBone;
 +extern StructRNA RNA_EffectSequence;
 +extern StructRNA RNA_EnumProperty;
 +extern StructRNA RNA_EnumPropertyItem;
 +extern StructRNA RNA_EnvironmentMap;
 +extern StructRNA RNA_EnvironmentMapTexture;
 +extern StructRNA RNA_Event;
 +extern StructRNA RNA_ExplodeModifier;
 +extern StructRNA RNA_ExpressionController;
 +extern StructRNA RNA_FCurve;
 +extern StructRNA RNA_FCurveSample;
 +extern StructRNA RNA_FModifier;
 +extern StructRNA RNA_FModifierCycles;
 +extern StructRNA RNA_FModifierEnvelope;
 +extern StructRNA RNA_FModifierEnvelopeControlPoint;
 +extern StructRNA RNA_FModifierFunctionGenerator;
 +extern StructRNA RNA_FModifierGenerator;
 +extern StructRNA RNA_FModifierLimits;
 +extern StructRNA RNA_FModifierNoise;
 +extern StructRNA RNA_FModifierPython;
 +extern StructRNA RNA_FieldSettings;
 +extern StructRNA RNA_FileSelectParams;
 +extern StructRNA RNA_FloatProperty;
 +extern StructRNA RNA_FloorConstraint;
 +extern StructRNA RNA_FluidFluidSettings;
 +extern StructRNA RNA_FluidSettings;
 +extern StructRNA RNA_FluidSimulationModifier;
 +extern StructRNA RNA_FollowPathConstraint;
 +extern StructRNA RNA_Function;
 +extern StructRNA RNA_GameBooleanProperty;
 +extern StructRNA RNA_GameFloatProperty;
 +extern StructRNA RNA_GameIntProperty;
 +extern StructRNA RNA_GameObjectSettings;
 +extern StructRNA RNA_GameProperty;
 +extern StructRNA RNA_GameSoftBodySettings;
 +extern StructRNA RNA_GameStringProperty;
 +extern StructRNA RNA_GameTimerProperty;
 +extern StructRNA RNA_GlowSequence;
 +extern StructRNA RNA_Group;
 +extern StructRNA RNA_Header;
 +extern StructRNA RNA_HemiLamp;
 +extern StructRNA RNA_HookModifier;
 +extern StructRNA RNA_ID;
 +extern StructRNA RNA_IDProperty;
 +extern StructRNA RNA_IDPropertyGroup;
 +extern StructRNA RNA_Image;
 +extern StructRNA RNA_ImagePaint;
 +extern StructRNA RNA_ImageSequence;
 +extern StructRNA RNA_ImageTexture;
 +extern StructRNA RNA_ImageUser;
 +extern StructRNA RNA_InflowFluidSettings;
 +extern StructRNA RNA_IntProperty;
 +extern StructRNA RNA_JoystickSensor;
 +extern StructRNA RNA_Key;
 +extern StructRNA RNA_KeyboardSensor;
 +extern StructRNA RNA_KeyingSet;
 +extern StructRNA RNA_KeyingSetPath;
 +extern StructRNA RNA_KinematicConstraint;
 +extern StructRNA RNA_Lamp;
 +extern StructRNA RNA_LampSkySettings;
 +extern StructRNA RNA_LampTextureSlot;
 +extern StructRNA RNA_Lattice;
 +extern StructRNA RNA_LatticeModifier;
 +extern StructRNA RNA_LatticePoint;
 +extern StructRNA RNA_Library;
 +extern StructRNA RNA_LimitDistanceConstraint;
 +extern StructRNA RNA_LimitLocationConstraint;
 +extern StructRNA RNA_LimitRotationConstraint;
 +extern StructRNA RNA_LimitScaleConstraint;
 +extern StructRNA RNA_LocalLamp;
 +extern StructRNA RNA_LockedTrackConstraint;
 +extern StructRNA RNA_MagicTexture;
 +extern StructRNA RNA_Main;
 +extern StructRNA RNA_MarbleTexture;
 +extern StructRNA RNA_MaskModifier;
 +extern StructRNA RNA_Material;
 +extern StructRNA RNA_MaterialHalo;
 +extern StructRNA RNA_MaterialRaytraceMirror;
 +extern StructRNA RNA_MaterialRaytraceTransparency;
 +extern StructRNA RNA_MaterialSlot;
 +extern StructRNA RNA_MaterialStrand;
 +extern StructRNA RNA_MaterialSubsurfaceScattering;
 +extern StructRNA RNA_MaterialTextureSlot;
 +extern StructRNA RNA_Menu;
 +extern StructRNA RNA_Mesh;
 +extern StructRNA RNA_MeshColor;
 +extern StructRNA RNA_MeshColorLayer;
 +extern StructRNA RNA_MeshDeformModifier;
 +extern StructRNA RNA_MeshEdge;
 +extern StructRNA RNA_MeshFace;
 +extern StructRNA RNA_MeshFloatProperty;
 +extern StructRNA RNA_MeshFloatPropertyLayer;
 +extern StructRNA RNA_MeshIntProperty;
 +extern StructRNA RNA_MeshIntPropertyLayer;
 +extern StructRNA RNA_MeshSticky;
 +extern StructRNA RNA_MeshStringProperty;
 +extern StructRNA RNA_MeshStringPropertyLayer;
 +extern StructRNA RNA_MeshTextureFace;
 +extern StructRNA RNA_MeshTextureFaceLayer;
 +extern StructRNA RNA_MeshVertex;
 +extern StructRNA RNA_MessageSensor;
 +extern StructRNA RNA_MetaBall;
 +extern StructRNA RNA_MetaElement;
 +extern StructRNA RNA_MetaSequence;
 +extern StructRNA RNA_MirrorModifier;
 +extern StructRNA RNA_Modifier;
 +extern StructRNA RNA_MouseSensor;
 +extern StructRNA RNA_MovieSequence;
 +extern StructRNA RNA_MultiresModifier;
 +extern StructRNA RNA_MusgraveTexture;
 +extern StructRNA RNA_NandController;
 +extern StructRNA RNA_NearSensor;
 +extern StructRNA RNA_NlaStrip;
 +extern StructRNA RNA_NlaTrack;
 +extern StructRNA RNA_Node;
 +extern StructRNA RNA_NodeTree;
 +extern StructRNA RNA_NoiseTexture;
 +extern StructRNA RNA_NorController;
 +extern StructRNA RNA_Nurb;
 +extern StructRNA RNA_Object;
 +extern StructRNA RNA_ObstacleFluidSettings;
 +extern StructRNA RNA_Operator;
 +extern StructRNA RNA_OperatorFileListElement;
 +extern StructRNA RNA_OperatorMousePath;
 +extern StructRNA RNA_OperatorProperties;
 +extern StructRNA RNA_OperatorStrokeElement;
 +extern StructRNA RNA_OrController;
 +extern StructRNA RNA_OutflowFluidSettings;
 +extern StructRNA RNA_PackedFile;
 +extern StructRNA RNA_Panel;
 +extern StructRNA RNA_Particle;
 +extern StructRNA RNA_ParticleFluidSettings;
 +extern StructRNA RNA_ParticleHairKey;
 +extern StructRNA RNA_ParticleInstanceModifier;
 +extern StructRNA RNA_ParticleKey;
 +extern StructRNA RNA_ParticleSettings;
 +extern StructRNA RNA_ParticleSystem;
 +extern StructRNA RNA_ParticleSystemModifier;
 +extern StructRNA RNA_ParticleTarget;
 +extern StructRNA RNA_PluginSequence;
 +extern StructRNA RNA_PluginTexture;
 +extern StructRNA RNA_PointCache;
++extern StructRNA RNA_PointDensity;
++extern StructRNA RNA_PointDensityTexture;
 +extern StructRNA RNA_PointerProperty;
 +extern StructRNA RNA_Pose;
 +extern StructRNA RNA_PoseChannel;
 +extern StructRNA RNA_Property;
 +extern StructRNA RNA_PropertySensor;
 +extern StructRNA RNA_PythonConstraint;
 +extern StructRNA RNA_PythonController;
 +extern StructRNA RNA_RadarSensor;
 +extern StructRNA RNA_RandomSensor;
 +extern StructRNA RNA_RaySensor;
 +extern StructRNA RNA_Region;
 +extern StructRNA RNA_RenderLayer;
 +extern StructRNA RNA_RenderPass;
 +extern StructRNA RNA_RenderResult;
 +extern StructRNA RNA_RenderValue;
 +extern StructRNA RNA_RigidBodyJointConstraint;
 +extern StructRNA RNA_Scene;
 +extern StructRNA RNA_SceneGameData;
 +extern StructRNA RNA_SceneRenderData;
 +extern StructRNA RNA_SceneRenderLayer;
 +extern StructRNA RNA_SceneSequence;
 +extern StructRNA RNA_Screen;
 +extern StructRNA RNA_Sculpt;
 +extern StructRNA RNA_Sensor;
 +extern StructRNA RNA_Sequence;
 +extern StructRNA RNA_SequenceColorBalance;
 +extern StructRNA RNA_SequenceCrop;
 +extern StructRNA RNA_SequenceEditor;
 +extern StructRNA RNA_SequenceElement;
 +extern StructRNA RNA_SequenceProxy;
 +extern StructRNA RNA_SequenceTransform;
 +extern StructRNA RNA_ShaderNode;
 +extern StructRNA RNA_ShaderNodeCameraData;
 +extern StructRNA RNA_ShaderNodeCombineRGB;
 +extern StructRNA RNA_ShaderNodeExtendedMaterial;
 +extern StructRNA RNA_ShaderNodeGeometry;
 +extern StructRNA RNA_ShaderNodeHueSaturation;
 +extern StructRNA RNA_ShaderNodeInvert;
 +extern StructRNA RNA_ShaderNodeMapping;
 +extern StructRNA RNA_ShaderNodeMaterial;
 +extern StructRNA RNA_ShaderNodeMath;
 +extern StructRNA RNA_ShaderNodeMixRGB;
 +extern StructRNA RNA_ShaderNodeNormal;
 +extern StructRNA RNA_ShaderNodeOutput;
 +extern StructRNA RNA_ShaderNodeRGB;
 +extern StructRNA RNA_ShaderNodeRGBCurve;
 +extern StructRNA RNA_ShaderNodeRGBToBW;
 +extern StructRNA RNA_ShaderNodeSeparateRGB;
 +extern StructRNA RNA_ShaderNodeSqueeze;
 +extern StructRNA RNA_ShaderNodeTexture;
 +extern StructRNA RNA_ShaderNodeValToRGB;
 +extern StructRNA RNA_ShaderNodeValue;
 +extern StructRNA RNA_ShaderNodeVectorCurve;
 +extern StructRNA RNA_ShaderNodeVectorMath;
 +extern StructRNA RNA_ShapeKey;
 +extern StructRNA RNA_ShapeKeyBezierPoint;
 +extern StructRNA RNA_ShapeKeyCurvePoint;
 +extern StructRNA RNA_ShapeKeyPoint;
 +extern StructRNA RNA_ShrinkwrapConstraint;
 +extern StructRNA RNA_ShrinkwrapModifier;
 +extern StructRNA RNA_SimpleDeformModifier;
 +extern StructRNA RNA_SmokeModifier;
 +extern StructRNA RNA_SmoothModifier;
 +extern StructRNA RNA_SoftBodyModifier;
 +extern StructRNA RNA_SoftBodySettings;
 +extern StructRNA RNA_Sound;
 +extern StructRNA RNA_SoundSequence;
 +extern StructRNA RNA_Space;
 +extern StructRNA RNA_Space3DView;
 +extern StructRNA RNA_SpaceButtonsWindow;
 +extern StructRNA RNA_SpaceConsole;
 +extern StructRNA RNA_SpaceDopeSheetEditor;
 +extern StructRNA RNA_SpaceFileBrowser;
 +extern StructRNA RNA_SpaceGraphEditor;
 +extern StructRNA RNA_SpaceImageEditor;
 +extern StructRNA RNA_SpaceNLA;
 +extern StructRNA RNA_SpaceOutliner;
 +extern StructRNA RNA_SpaceSequenceEditor;
 +extern StructRNA RNA_SpaceTextEditor;
 +extern StructRNA RNA_SpaceUVEditor;
 +extern StructRNA RNA_SpeedControlSequence;
 +extern StructRNA RNA_SpotLamp;
 +extern StructRNA RNA_StretchToConstraint;
 +extern StructRNA RNA_StringProperty;
 +extern StructRNA RNA_Struct;
 +extern StructRNA RNA_StucciTexture;
 +extern StructRNA RNA_SubsurfModifier;
 +extern StructRNA RNA_SunLamp;
 +extern StructRNA RNA_SurfaceCurve;
 +extern StructRNA RNA_SurfaceModifier;
 +extern StructRNA RNA_TexMapping;
 +extern StructRNA RNA_Text;
 +extern StructRNA RNA_TextBox;
 +extern StructRNA RNA_TextCharacterFormat;
 +extern StructRNA RNA_TextCurve;
 +extern StructRNA RNA_TextLine;
 +extern StructRNA RNA_TextMarker;
 +extern StructRNA RNA_Texture;
 +extern StructRNA RNA_TextureNode;
 +extern StructRNA RNA_TextureNodeBricks;
 +extern StructRNA RNA_TextureNodeChecker;
 +extern StructRNA RNA_TextureNodeCompose;
 +extern StructRNA RNA_TextureNodeCoordinates;
 +extern StructRNA RNA_TextureNodeCurveRGB;
 +extern StructRNA RNA_TextureNodeCurveTime;
 +extern StructRNA RNA_TextureNodeDecompose;
 +extern StructRNA RNA_TextureNodeDistance;
 +extern StructRNA RNA_TextureNodeHueSaturation;
 +extern StructRNA RNA_TextureNodeImage;
 +extern StructRNA RNA_TextureNodeInvert;
 +extern StructRNA RNA_TextureNodeMath;
 +extern StructRNA RNA_TextureNodeMixRGB;
 +extern StructRNA RNA_TextureNodeOutput;
 +extern StructRNA RNA_TextureNodeRGBToBW;
 +extern StructRNA RNA_TextureNodeRotate;
 +extern StructRNA RNA_TextureNodeScale;
 +extern StructRNA RNA_TextureNodeTexture;
 +extern StructRNA RNA_TextureNodeTranslate;
 +extern StructRNA RNA_TextureNodeValToNor;
 +extern StructRNA RNA_TextureNodeValToRGB;
 +extern StructRNA RNA_TextureNodeViewer;
 +extern StructRNA RNA_TextureSlot;
 +extern StructRNA RNA_Theme;
 +extern StructRNA RNA_ThemeAudioWindow;
 +extern StructRNA RNA_ThemeBoneColorSet;
 +extern StructRNA RNA_ThemeButtonsWindow;
 +extern StructRNA RNA_ThemeDopeSheet;
 +extern StructRNA RNA_ThemeFileBrowser;
 +extern StructRNA RNA_ThemeFontStyle;
 +extern StructRNA RNA_ThemeGraphEditor;
 +extern StructRNA RNA_ThemeImageEditor;
 +extern StructRNA RNA_ThemeLogicEditor;
 +extern StructRNA RNA_ThemeNLAEditor;
 +extern StructRNA RNA_ThemeNodeEditor;
 +extern StructRNA RNA_ThemeOutliner;
 +extern StructRNA RNA_ThemeSequenceEditor;
 +extern StructRNA RNA_ThemeStyle;
 +extern StructRNA RNA_ThemeTextEditor;
 +extern StructRNA RNA_ThemeTimeline;
 +extern StructRNA RNA_ThemeUserInterface;
 +extern StructRNA RNA_ThemeUserPreferences;
 +extern StructRNA RNA_ThemeView3D;
 +extern StructRNA RNA_ThemeWidgetColors;
 +extern StructRNA RNA_ThemeWidgetStateColors;
 +extern StructRNA RNA_TimelineMarker;
 +extern StructRNA RNA_ToolSettings;
 +extern StructRNA RNA_TouchSensor;
 +extern StructRNA RNA_TrackToConstraint;
 +extern StructRNA RNA_TransformConstraint;
 +extern StructRNA RNA_TransformSequence;
 +extern StructRNA RNA_UILayout;
 +extern StructRNA RNA_UIListItem;
 +extern StructRNA RNA_UVProjectModifier;
 +extern StructRNA RNA_UnknownType;
 +extern StructRNA RNA_UserPreferences;
 +extern StructRNA RNA_UserPreferencesAutosave;
 +extern StructRNA RNA_UserPreferencesEdit;
 +extern StructRNA RNA_UserPreferencesFilePaths;
 +extern StructRNA RNA_UserPreferencesLanguage;
 +extern StructRNA RNA_UserPreferencesSystem;
 +extern StructRNA RNA_UserPreferencesView;
 +extern StructRNA RNA_UserSolidLight;
 +extern StructRNA RNA_VertexPaint;
 +extern StructRNA RNA_VectorFont;
 +extern StructRNA RNA_VertexGroup;
 +extern StructRNA RNA_VertexGroupElement;
 +extern StructRNA RNA_VoronoiTexture;
++extern StructRNA RNA_VoxelData;
++extern StructRNA RNA_VoxelDataTexture;
 +extern StructRNA RNA_WaveModifier;
 +extern StructRNA RNA_Window;
 +extern StructRNA RNA_WindowManager;
 +extern StructRNA RNA_WipeSequence;
 +extern StructRNA RNA_WoodTexture;
 +extern StructRNA RNA_World;
 +extern StructRNA RNA_WorldAmbientOcclusion;
 +extern StructRNA RNA_WorldMistSettings;
 +extern StructRNA RNA_WorldStarsSettings;
 +extern StructRNA RNA_WorldTextureSlot;
 +extern StructRNA RNA_XnorController;
 +extern StructRNA RNA_XorController;
 +
 +/* Pointer
 + *
 + * These functions will fill in RNA pointers, this can be done in three ways:
 + * - a pointer Main is created by just passing the data pointer
 + * - a pointer to a datablock can be created with the type and id data pointer
 + * - a pointer to data contained in a datablock can be created with the id type
 + *   and id data pointer, and the data type and pointer to the struct itself.
 + *
 + * There is also a way to get a pointer with the information about all structs.
 + */
 +
 +void RNA_main_pointer_create(struct Main *main, PointerRNA *r_ptr);
 +void RNA_id_pointer_create(struct ID *id, PointerRNA *r_ptr);
 +void RNA_pointer_create(struct ID *id, StructRNA *type, void *data, PointerRNA *r_ptr);
 +
 +void RNA_blender_rna_pointer_create(PointerRNA *r_ptr);
 +
 +extern PointerRNA PointerRNA_NULL;
 +
 +/* Structs */
 +
 +const char *RNA_struct_identifier(StructRNA *type);
 +const char *RNA_struct_ui_name(StructRNA *type);
 +const char *RNA_struct_ui_description(StructRNA *type);
 +int RNA_struct_ui_icon(StructRNA *type);
 +
 +PropertyRNA *RNA_struct_name_property(StructRNA *type);
 +PropertyRNA *RNA_struct_iterator_property(StructRNA *type);
 +StructRNA *RNA_struct_base(StructRNA *type);
 +
 +int RNA_struct_is_ID(StructRNA *type);
 +int RNA_struct_is_a(StructRNA *type, StructRNA *srna);
 +
 +StructRegisterFunc RNA_struct_register(StructRNA *type);
 +StructUnregisterFunc RNA_struct_unregister(StructRNA *type);
 +
 +void *RNA_struct_py_type_get(StructRNA *srna);
 +void RNA_struct_py_type_set(StructRNA *srna, void *py_type);
 +
 +void *RNA_struct_blender_type_get(StructRNA *srna);
 +void RNA_struct_blender_type_set(StructRNA *srna, void *blender_type);
 +
 +struct IDProperty *RNA_struct_idproperties(PointerRNA *ptr, int create);
 +
 +PropertyRNA *RNA_struct_find_property(PointerRNA *ptr, const char *identifier);
 +const struct ListBase *RNA_struct_defined_properties(StructRNA *srna);
 +
 +FunctionRNA *RNA_struct_find_function(PointerRNA *ptr, const char *identifier);
 +const struct ListBase *RNA_struct_defined_functions(StructRNA *srna);
 +
 +char *RNA_struct_name_get_alloc(PointerRNA *ptr, char *fixedbuf, int fixedlen);
 +
 +/* Properties
 + *
 + * Access to struct properties. All this works with RNA pointers rather than
 + * direct pointers to the data. */
 +
 +/* Property Information */
 +
 +const char *RNA_property_identifier(PropertyRNA *prop);
 +PropertyType RNA_property_type(PropertyRNA *prop);
 +PropertySubType RNA_property_subtype(PropertyRNA *prop);
 +PropertyUnit RNA_property_unit(PropertyRNA *prop);
 +int RNA_property_flag(PropertyRNA *prop);
 +
 +int RNA_property_array_length(PropertyRNA *prop);
 +char RNA_property_array_item_char(PropertyRNA *prop, int index);
 +
 +int RNA_property_string_maxlength(PropertyRNA *prop);
 +
 +const char *RNA_property_ui_name(PropertyRNA *prop);
 +const char *RNA_property_ui_description(PropertyRNA *prop);
 +int RNA_property_ui_icon(PropertyRNA *prop);
 +
 +/* Dynamic Property Information */
 +
 +void RNA_property_int_range(PointerRNA *ptr, PropertyRNA *prop, int *hardmin, int *hardmax);
 +void RNA_property_int_ui_range(PointerRNA *ptr, PropertyRNA *prop, int *softmin, int *softmax, int *step);
 +
 +void RNA_property_float_range(PointerRNA *ptr, PropertyRNA *prop, float *hardmin, float *hardmax);
 +void RNA_property_float_ui_range(PointerRNA *ptr, PropertyRNA *prop, float *softmin, float *softmax, float *step, float *precision);
 +
 +int RNA_enum_identifier(EnumPropertyItem *item, const int value, const char **identifier);
 +int RNA_enum_name(EnumPropertyItem *item, const int value, const char **name);
 +
 +void RNA_property_enum_items(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, EnumPropertyItem **item, int *totitem, int *free);
 +int RNA_property_enum_value(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, const char *identifier, int *value);
 +int RNA_property_enum_identifier(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, const int value, const char **identifier);
 +
 +StructRNA *RNA_property_pointer_type(PointerRNA *ptr, PropertyRNA *prop);
 +
 +int RNA_property_editable(PointerRNA *ptr, PropertyRNA *prop);
 +int RNA_property_animateable(PointerRNA *ptr, PropertyRNA *prop);
 +int RNA_property_animated(PointerRNA *ptr, PropertyRNA *prop);
 +
 +void RNA_property_update(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop);
 +
 +/* Property Data */
 +
 +int RNA_property_boolean_get(PointerRNA *ptr, PropertyRNA *prop);
 +void RNA_property_boolean_set(PointerRNA *ptr, PropertyRNA *prop, int value);
 +void RNA_property_boolean_get_array(PointerRNA *ptr, PropertyRNA *prop, int *values);
 +int RNA_property_boolean_get_index(PointerRNA *ptr, PropertyRNA *prop, int index);
 +void RNA_property_boolean_set_array(PointerRNA *ptr, PropertyRNA *prop, const int *values);
 +void RNA_property_boolean_set_index(PointerRNA *ptr, PropertyRNA *prop, int index, int value);
 +
 +int RNA_property_int_get(PointerRNA *ptr, PropertyRNA *prop);
 +void RNA_property_int_set(PointerRNA *ptr, PropertyRNA *prop, int value);
 +void RNA_property_int_get_array(PointerRNA *ptr, PropertyRNA *prop, int *values);
 +int RNA_property_int_get_index(PointerRNA *ptr, PropertyRNA *prop, int index);
 +void RNA_property_int_set_array(PointerRNA *ptr, PropertyRNA *prop, const int *values);
 +void RNA_property_int_set_index(PointerRNA *ptr, PropertyRNA *prop, int index, int value);
 +
 +float RNA_property_float_get(PointerRNA *ptr, PropertyRNA *prop);
 +void RNA_property_float_set(PointerRNA *ptr, PropertyRNA *prop, float value);
 +void RNA_property_float_get_array(PointerRNA *ptr, PropertyRNA *prop, float *values);
 +float RNA_property_float_get_index(PointerRNA *ptr, PropertyRNA *prop, int index);
 +void RNA_property_float_set_array(PointerRNA *ptr, PropertyRNA *prop, const float *values);
 +void RNA_property_float_set_index(PointerRNA *ptr, PropertyRNA *prop, int index, float value);
 +
 +void RNA_property_string_get(PointerRNA *ptr, PropertyRNA *prop, char *value);
 +char *RNA_property_string_get_alloc(PointerRNA *ptr, PropertyRNA *prop, char *fixedbuf, int fixedlen);
 +int RNA_property_string_length(PointerRNA *ptr, PropertyRNA *prop);
 +void RNA_property_string_set(PointerRNA *ptr, PropertyRNA *prop, const char *value);
 +
 +int RNA_property_enum_get(PointerRNA *ptr, PropertyRNA *prop);
 +void RNA_property_enum_set(PointerRNA *ptr, PropertyRNA *prop, int value);
 +
 +PointerRNA RNA_property_pointer_get(PointerRNA *ptr, PropertyRNA *prop);
 +void RNA_property_pointer_set(PointerRNA *ptr, PropertyRNA *prop, PointerRNA ptr_value);
 +
 +void RNA_property_collection_begin(PointerRNA *ptr, PropertyRNA *prop, CollectionPropertyIterator *iter);
 +void RNA_property_collection_next(CollectionPropertyIterator *iter);
 +void RNA_property_collection_end(CollectionPropertyIterator *iter);
 +int RNA_property_collection_length(PointerRNA *ptr, PropertyRNA *prop);
 +int RNA_property_collection_lookup_int(PointerRNA *ptr, PropertyRNA *prop, int key, PointerRNA *r_ptr);
 +int RNA_property_collection_lookup_string(PointerRNA *ptr, PropertyRNA *prop, const char *key, PointerRNA *r_ptr);
 +
 +/* efficient functions to set properties for arrays */
 +int RNA_property_collection_raw_array(PointerRNA *ptr, PropertyRNA *prop, PropertyRNA *itemprop, RawArray *array);
 +int RNA_property_collection_raw_get(struct ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, char *propname, void *array, RawPropertyType type, int len);
 +int RNA_property_collection_raw_set(struct ReportList *reports, PointerRNA *ptr, PropertyRNA *prop, char *propname, void *array, RawPropertyType type, int len);
 +int RNA_raw_type_sizeof(RawPropertyType type);
 +RawPropertyType RNA_property_raw_type(PropertyRNA *prop);
 +
 +
 +/* to create ID property groups */
 +void RNA_property_pointer_add(PointerRNA *ptr, PropertyRNA *prop);
 +void RNA_property_pointer_remove(PointerRNA *ptr, PropertyRNA *prop);
 +void RNA_property_collection_add(PointerRNA *ptr, PropertyRNA *prop, PointerRNA *r_ptr);
 +void RNA_property_collection_remove(PointerRNA *ptr, PropertyRNA *prop, int key);
 +void RNA_property_collection_clear(PointerRNA *ptr, PropertyRNA *prop);
 +
 +/* Path
 + *
 + * Experimental method to refer to structs and properties with a string,
 + * using a syntax like: scenes[0].objects["Cube"].data.verts[7].co
 + *
 + * This provides a way to refer to RNA data while being detached from any
 + * particular pointers, which is useful in a number of applications, like
 + * UI code or Actions, though efficiency is a concern. */
 +
 +char *RNA_path_append(const char *path, PointerRNA *ptr, PropertyRNA *prop,
 +      int intkey, const char *strkey);
 +char *RNA_path_back(const char *path);
 +
 +int RNA_path_resolve(PointerRNA *ptr, const char *path,
 +      PointerRNA *r_ptr, PropertyRNA **r_prop);
 +
 +char *RNA_path_from_ID_to_property(PointerRNA *ptr, PropertyRNA *prop);
 +
 +#if 0
 +/* Dependency
 + *
 + * Experimental code that will generate callbacks for each dependency
 + * between ID types. This may end up being useful for UI
 + * and evaluation code that needs to know such dependencies for correct
 + * redraws and re-evaluations. */
 +
 +typedef void (*PropDependencyCallback)(void *udata, PointerRNA *from, PointerRNA *to);
 +void RNA_test_dependencies_cb(void *udata, PointerRNA *from, PointerRNA *to);
 +
 +void RNA_generate_dependencies(PointerRNA *mainptr, void *udata, PropDependencyCallback cb);
 +#endif
 +
 +/* Quick name based property access
 + *
 + * These are just an easier way to access property values without having to
 + * call RNA_struct_find_property. The names have to exist as RNA properties
 + * for the type in the pointer, if they do not exist an error will be printed.
 + *
 + * There is no support for pointers and collections here yet, these can be 
 + * added when ID properties support them. */
 +
 +int RNA_boolean_get(PointerRNA *ptr, const char *name);
 +void RNA_boolean_set(PointerRNA *ptr, const char *name, int value);
 +void RNA_boolean_get_array(PointerRNA *ptr, const char *name, int *values);
 +void RNA_boolean_set_array(PointerRNA *ptr, const char *name, const int *values);
 +
 +int RNA_int_get(PointerRNA *ptr, const char *name);
 +void RNA_int_set(PointerRNA *ptr, const char *name, int value);
 +void RNA_int_get_array(PointerRNA *ptr, const char *name, int *values);
 +void RNA_int_set_array(PointerRNA *ptr, const char *name, const int *values);
 +
 +float RNA_float_get(PointerRNA *ptr, const char *name);
 +void RNA_float_set(PointerRNA *ptr, const char *name, float value);
 +void RNA_float_get_array(PointerRNA *ptr, const char *name, float *values);
 +void RNA_float_set_array(PointerRNA *ptr, const char *name, const float *values);
 +
 +int RNA_enum_get(PointerRNA *ptr, const char *name);
 +void RNA_enum_set(PointerRNA *ptr, const char *name, int value);
 +int RNA_enum_is_equal(struct bContext *C, PointerRNA *ptr, const char *name, const char *enumname);
 +
 +/* lower level functions that donr use a PointerRNA */
 +int   RNA_enum_value_from_id(EnumPropertyItem *item, const char *identifier, int *value);
 +int   RNA_enum_id_from_value(EnumPropertyItem *item, int value, const char **identifier);
 +
 +void RNA_string_get(PointerRNA *ptr, const char *name, char *value);
 +char *RNA_string_get_alloc(PointerRNA *ptr, const char *name, char *fixedbuf, int fixedlen);
 +int RNA_string_length(PointerRNA *ptr, const char *name);
 +void RNA_string_set(PointerRNA *ptr, const char *name, const char *value);
 +
 +PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name);
 +void RNA_pointer_set(PointerRNA *ptr, const char *name, PointerRNA ptr_value);
 +void RNA_pointer_add(PointerRNA *ptr, const char *name);
 +
 +void RNA_collection_begin(PointerRNA *ptr, const char *name, CollectionPropertyIterator *iter);
 +int RNA_collection_length(PointerRNA *ptr, const char *name);
 +void RNA_collection_add(PointerRNA *ptr, const char *name, PointerRNA *r_value);
 +void RNA_collection_clear(PointerRNA *ptr, const char *name);
 +
 +#define RNA_BEGIN(sptr, itemptr, propname) \
 +      { \
 +              CollectionPropertyIterator rna_macro_iter; \
 +              for(RNA_collection_begin(sptr, propname, &rna_macro_iter); rna_macro_iter.valid; RNA_property_collection_next(&rna_macro_iter)) { \
 +                      PointerRNA itemptr= rna_macro_iter.ptr;
 +
 +#define RNA_END \
 +              } \
 +              RNA_property_collection_end(&rna_macro_iter); \
 +      }
 +
 +#define RNA_PROP_BEGIN(sptr, itemptr, prop) \
 +      { \
 +              CollectionPropertyIterator rna_macro_iter; \
 +              for(RNA_property_collection_begin(sptr, prop, &rna_macro_iter); rna_macro_iter.valid; RNA_property_collection_next(&rna_macro_iter)) { \
 +                      PointerRNA itemptr= rna_macro_iter.ptr;
 +
 +#define RNA_PROP_END \
 +              } \
 +              RNA_property_collection_end(&rna_macro_iter); \
 +      }
 +
 +#define RNA_STRUCT_BEGIN(sptr, prop) \
 +      { \
 +              CollectionPropertyIterator rna_macro_iter; \
 +              for(RNA_property_collection_begin(sptr, RNA_struct_iterator_property(sptr->type), &rna_macro_iter); rna_macro_iter.valid; RNA_property_collection_next(&rna_macro_iter)) { \
 +                      PropertyRNA *prop= rna_macro_iter.ptr.data;
 +
 +#define RNA_STRUCT_END \
 +              } \
 +              RNA_property_collection_end(&rna_macro_iter); \
 +      }
 +
 +/* check if the idproperty exists, for operators */
 +int RNA_property_is_set(PointerRNA *ptr, const char *name);
 +
 +/* python compatible string representation of this property, (must be freed!) */
 +char *RNA_property_as_string(PointerRNA *ptr, PropertyRNA *prop);
 +char *RNA_pointer_as_string(PointerRNA *ptr);
 +
 +/* Function */
 +
 +const char *RNA_function_identifier(FunctionRNA *func);
 +PropertyRNA *RNA_function_return(FunctionRNA *func);
 +const char *RNA_function_ui_description(FunctionRNA *func);
 +int RNA_function_flag(FunctionRNA *func);
 +
 +PropertyRNA *RNA_function_get_parameter(PointerRNA *ptr, FunctionRNA *func, int index);
 +PropertyRNA *RNA_function_find_parameter(PointerRNA *ptr, FunctionRNA *func, const char *identifier);
 +const struct ListBase *RNA_function_defined_parameters(FunctionRNA *func);
 +
 +/* Utility */
 +
 +ParameterList *RNA_parameter_list_create(ParameterList *parms, PointerRNA *ptr, FunctionRNA *func);
 +void RNA_parameter_list_free(ParameterList *parms);
 +int  RNA_parameter_list_size(ParameterList *parms);
 +
 +void RNA_parameter_list_begin(ParameterList *parms, ParameterIterator *iter);
 +void RNA_parameter_list_next(ParameterIterator *iter);
 +void RNA_parameter_list_end(ParameterIterator *iter);
 +
 +void RNA_parameter_get(ParameterList *parms, PropertyRNA *parm, void **value);
 +void RNA_parameter_get_lookup(ParameterList *parms, const char *identifier, void **value);
 +void RNA_parameter_set(ParameterList *parms, PropertyRNA *parm, void *value);
 +void RNA_parameter_set_lookup(ParameterList *parms, const char *identifier, void *value);
 +
 +int RNA_function_call(struct bContext *C, struct ReportList *reports, PointerRNA *ptr, FunctionRNA *func, ParameterList *parms);
 +int RNA_function_call_lookup(struct bContext *C, struct ReportList *reports, PointerRNA *ptr, const char *identifier, ParameterList *parms);
 +
 +int RNA_function_call_direct(struct bContext *C, struct ReportList *reports, PointerRNA *ptr, FunctionRNA *func, const char *format, ...);
 +int RNA_function_call_direct_lookup(struct bContext *C, struct ReportList *reports, PointerRNA *ptr, const char *identifier, const char *format, ...);
 +int RNA_function_call_direct_va(struct bContext *C, struct ReportList *reports, PointerRNA *ptr, FunctionRNA *func, const char *format, va_list args);
 +int RNA_function_call_direct_va_lookup(struct bContext *C, struct ReportList *reports, PointerRNA *ptr, const char *identifier, const char *format, va_list args);
 +
 +/* ID */
 +
 +short RNA_type_to_ID_code(StructRNA *type);
 +StructRNA *ID_code_to_RNA_type(short idcode);
 +
 +#ifdef __cplusplus
 +}
 +#endif
 +
 +#endif /* RNA_ACCESS */
 +
index 4ac3996d0a57b78abdf04d2e57e74114f7427e5d,0000000000000000000000000000000000000000..4ca1db09374422563d369e290d8774c8f37e03e4
mode 100644,000000..100644
--- /dev/null
@@@ -1,1424 -1,0 +1,1572 @@@
-               // {MA_TYPE_VOLUME, "VOLUME", 0, "Volume", "Render object as a volume."},
 +/**
 + * $Id$
 + *
 + * ***** BEGIN GPL 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.
 + *
 + * 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.
 + *
 + * Contributor(s): Blender Foundation (2008), Nathan Letwory
 + *
 + * ***** END GPL LICENSE BLOCK *****
 + */
 +
 +#include <float.h>
 +#include <stdlib.h>
 +
 +#include "RNA_define.h"
 +#include "RNA_types.h"
 +
 +#include "rna_internal.h"
 +
 +#include "DNA_material_types.h"
 +#include "DNA_texture_types.h"
 +
 +#include "WM_types.h"
 +
 +#ifdef RNA_RUNTIME
 +
 +#include "MEM_guardedalloc.h"
 +
 +#include "BKE_texture.h"
 +
 +static PointerRNA rna_Material_mirror_get(PointerRNA *ptr)
 +{
 +      return rna_pointer_inherit_refine(ptr, &RNA_MaterialRaytraceMirror, ptr->id.data);
 +}
 +
 +static PointerRNA rna_Material_transp_get(PointerRNA *ptr)
 +{
 +      return rna_pointer_inherit_refine(ptr, &RNA_MaterialRaytraceTransparency, ptr->id.data);
 +}
 +
 +static PointerRNA rna_Material_halo_get(PointerRNA *ptr)
 +{
 +      return rna_pointer_inherit_refine(ptr, &RNA_MaterialHalo, ptr->id.data);
 +}
 +
 +static PointerRNA rna_Material_sss_get(PointerRNA *ptr)
 +{
 +      return rna_pointer_inherit_refine(ptr, &RNA_MaterialSubsurfaceScattering, ptr->id.data);
 +}
 +
 +static PointerRNA rna_Material_strand_get(PointerRNA *ptr)
 +{
 +      return rna_pointer_inherit_refine(ptr, &RNA_MaterialStrand, ptr->id.data);
 +}
 +
 +static PointerRNA rna_Material_physics_get(PointerRNA *ptr)
 +{
 +      return rna_pointer_inherit_refine(ptr, &RNA_MaterialPhysics, ptr->id.data);
 +}
 +
 +static void rna_Material_type_set(PointerRNA *ptr, int value)
 +{
 +      Material *ma= (Material*)ptr->data;
 +
 +      if(ma->material_type == MA_TYPE_HALO && value != MA_TYPE_HALO)
 +              ma->mode &= ~(MA_STAR|MA_HALO_XALPHA|MA_ZINV|MA_ENV);
 +
 +      ma->material_type= value;
 +}
 +
 +static void rna_Material_mtex_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 +{
 +      Material *ma= (Material*)ptr->data;
 +      rna_iterator_array_begin(iter, (void*)ma->mtex, sizeof(MTex*), MAX_MTEX, 0, NULL);
 +}
 +
 +static PointerRNA rna_Material_active_texture_get(PointerRNA *ptr)
 +{
 +      Material *ma= (Material*)ptr->data;
 +      Tex *tex;
 +
 +      tex= (ma->mtex[(int)ma->texact])? ma->mtex[(int)ma->texact]->tex: NULL;
 +      return rna_pointer_inherit_refine(ptr, &RNA_Texture, tex);
 +}
 +
 +static void rna_Material_active_texture_set(PointerRNA *ptr, PointerRNA value)
 +{
 +      Material *ma= (Material*)ptr->data;
 +      int act= ma->texact;
 +
 +      if(ma->mtex[act] && ma->mtex[act]->tex)
 +              id_us_min(&ma->mtex[act]->tex->id);
 +
 +      if(value.data) {
 +              if(!ma->mtex[act])
 +                      ma->mtex[act]= add_mtex();
 +              
 +              ma->mtex[act]->tex= value.data;
 +              id_us_plus(&ma->mtex[act]->tex->id);
 +      }
 +      else if(ma->mtex[act]) {
 +              MEM_freeN(ma->mtex[act]);
 +              ma->mtex[act]= NULL;
 +      }
 +}
 +
 +static void rna_MaterialStrand_start_size_range(PointerRNA *ptr, float *min, float *max)
 +{
 +      Material *ma= (Material*)ptr->id.data;
 +
 +      if(ma->mode & MA_STR_B_UNITS) {
 +              *min= 0.0001f;
 +              *max= 2.0f;
 +      }
 +      else {
 +              *min= 0.25f;
 +              *max= 20.0f;
 +      }
 +}
 +
 +static void rna_MaterialStrand_end_size_range(PointerRNA *ptr, float *min, float *max)
 +{
 +      Material *ma= (Material*)ptr->id.data;
 +
 +      if(ma->mode & MA_STR_B_UNITS) {
 +              *min= 0.0001f;
 +              *max= 1.0f;
 +      }
 +      else {
 +              *min= 0.25f;
 +              *max= 10.0f;
 +      }
 +}
 +
 +static int rna_MaterialTextureSlot_enabled_get(PointerRNA *ptr)
 +{
 +      Material *ma= (Material*)ptr->id.data;
 +      MTex *mtex= (MTex*)ptr->data;
 +      int a;
 +
 +      for(a=0; a<MAX_MTEX; a++)
 +              if(ma->mtex[a] == mtex)
 +                      return (ma->septex & (1<<a)) == 0;
 +      
 +      return 0;
 +}
 +
 +static void rna_MaterialTextureSlot_enabled_set(PointerRNA *ptr, int value)
 +{
 +      Material *ma= (Material*)ptr->id.data;
 +      MTex *mtex= (MTex*)ptr->data;
 +      int a;
 +
 +      for(a=0; a<MAX_MTEX; a++) {
 +              if(ma->mtex[a] == mtex) {
 +                      if(value)
 +                              ma->septex &= ~(1<<a);
 +                      else
 +                              ma->septex |= (1<<a);
 +              }
 +      }
 +}
 +
 +static void rna_Material_use_diffuse_ramp_set(PointerRNA *ptr, int value)
 +{
 +      Material *ma= (Material*)ptr->data;
 +
 +      if(value) ma->mode |= MA_RAMP_COL;
 +      else ma->mode &= ~MA_RAMP_COL;
 +
 +      if((ma->mode & MA_RAMP_COL) && ma->ramp_col == NULL)
 +              ma->ramp_col= add_colorband(0);
 +}
 +
 +static void rna_Material_use_specular_ramp_set(PointerRNA *ptr, int value)
 +{
 +      Material *ma= (Material*)ptr->data;
 +
 +      if(value) ma->mode |= MA_RAMP_SPEC;
 +      else ma->mode &= ~MA_RAMP_SPEC;
 +
 +      if((ma->mode & MA_RAMP_SPEC) && ma->ramp_spec == NULL)
 +              ma->ramp_spec= add_colorband(0);
 +}
 +
 +#else
 +
 +static void rna_def_material_mtex(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_texture_coordinates_items[] = {
 +              {TEXCO_GLOB, "GLOBAL", 0, "Global", "Uses global coordinates for the texture coordinates."},
 +              {TEXCO_OBJECT, "OBJECT", 0, "Object", "Uses linked object's coordinates for texture coordinates."},
 +              {TEXCO_UV, "UV", 0, "UV", "Uses UV coordinates for texture coordinates."},
 +              {TEXCO_ORCO, "ORCO", 0, "Generated", "Uses the original undeformed coordinates of the object."},
 +              {TEXCO_STRAND, "STRAND", 0, "Strand", "Uses normalized strand texture coordinate (1D)."},
 +              {TEXCO_STICKY, "STICKY", 0, "Sticky", "Uses mesh's sticky coordinates for the texture coordinates."},
 +              {TEXCO_WINDOW, "WINDOW", 0, "Window", "Uses screen coordinates as texture coordinates."},
 +              {TEXCO_NORM, "NORMAL", 0, "Normal", "Uses normal vector as texture coordinates."},
 +              {TEXCO_REFL, "REFLECTION", 0, "Reflection", "Uses reflection vector as texture coordinates."},
 +              {TEXCO_STRESS, "STRESS", 0, "Stress", "Uses the difference of edge lengths compared to original coordinates of the mesh."},
 +              {TEXCO_TANGENT, "TANGENT", 0, "Tangent", "Uses the optional tangent vector as texture coordinates."},
 +
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      static EnumPropertyItem prop_mapping_items[] = {
 +              {MTEX_FLAT, "FLAT", 0, "Flat", "Maps X and Y coordinates directly."},
 +              {MTEX_CUBE, "CUBE", 0, "Cube", "Maps using the normal vector."},
 +              {MTEX_TUBE, "TUBE", 0, "Tube", "Maps with Z as central axis."},
 +              {MTEX_SPHERE, "SPHERE", 0, "Sphere", "Maps with Z as central axis."},
 +              {0, NULL, 0, NULL, NULL}};
 +              
 +      static EnumPropertyItem prop_x_mapping_items[] = {
 +              {0, "NONE", 0, "None", ""},
 +              {1, "X", 0, "X", ""},
 +              {2, "Y", 0, "Y", ""},
 +              {3, "Z", 0, "Z", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +              
 +      static EnumPropertyItem prop_y_mapping_items[] = {
 +              {0, "NONE", 0, "None", ""},
 +              {1, "X", 0, "X", ""},
 +              {2, "Y", 0, "Y", ""},
 +              {3, "Z", 0, "Z", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +              
 +      static EnumPropertyItem prop_z_mapping_items[] = {
 +              {0, "NONE", 0, "None", ""},
 +              {1, "X", 0, "X", ""},
 +              {2, "Y", 0, "Y", ""},
 +              {3, "Z", 0, "Z", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      static EnumPropertyItem prop_normal_map_space_items[] = {
 +              {MTEX_NSPACE_CAMERA, "CAMERA", 0, "Camera", ""},
 +              {MTEX_NSPACE_WORLD, "WORLD", 0, "World", ""},
 +              {MTEX_NSPACE_OBJECT, "OBJECT", 0, "Object", ""},
 +              {MTEX_NSPACE_TANGENT, "TANGENT", 0, "Tangent", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "MaterialTextureSlot", "TextureSlot");
 +      RNA_def_struct_sdna(srna, "MTex");
 +      RNA_def_struct_ui_text(srna, "Material Texture Slot", "Texture slot for textures in a Material datablock.");
 +
 +      prop= RNA_def_property(srna, "texture_coordinates", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "texco");
 +      RNA_def_property_enum_items(prop, prop_texture_coordinates_items);
 +      RNA_def_property_ui_text(prop, "Texture Coordinates", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "object");
 +      RNA_def_property_struct_type(prop, "Object");
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Object", "Object to use for mapping with Object texture coordinates.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
 +      RNA_def_property_string_sdna(prop, NULL, "uvname");
 +      RNA_def_property_ui_text(prop, "UV Layer", "UV layer to use for mapping with UV texture coordinates.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "from_dupli", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "texflag", MTEX_DUPLI_MAPTO);
 +      RNA_def_property_ui_text(prop, "From Dupli", "Dupli's instanced from verts, faces or particles, inherit texture coordinate from their parent.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "from_original", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "texflag", MTEX_OB_DUPLI_ORIG);
 +      RNA_def_property_ui_text(prop, "From Original", "Dupli's derive their object coordinates from the original objects transformation.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "map_colordiff", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_COL);
 +      RNA_def_property_ui_text(prop, "Diffuse Color", "Causes the texture to affect basic color of the material");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_normal", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_NORM);
 +      RNA_def_property_ui_text(prop, "Normal", "Causes the texture to affect the rendered normal");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_colorspec", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_COLSPEC);
 +      RNA_def_property_ui_text(prop, "Specular Color", "Causes the texture to affect the specularity color");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_mirror", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_COLMIR);
 +      RNA_def_property_ui_text(prop, "Mirror", "Causes the texture to affect the mirror color");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_diffuse", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_REF);
 +      RNA_def_property_ui_text(prop, "Diffuse", "Causes the texture to affect the value of the materials diffuse reflectivity");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_specular", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_SPEC);
 +      RNA_def_property_ui_text(prop, "Specular", "Causes the texture to affect the value of specular reflectivity");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_ambient", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_AMB);
 +      RNA_def_property_ui_text(prop, "Ambient", "Causes the texture to affect the value of ambient");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_hardness", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_HAR);
 +      RNA_def_property_ui_text(prop, "Hardness", "Causes the texture to affect the hardness value");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_raymir", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_RAYMIRR);
 +      RNA_def_property_ui_text(prop, "Ray-Mirror", "Causes the texture to affect the ray-mirror value");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_alpha", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_ALPHA);
 +      RNA_def_property_ui_text(prop, "Alpha", "Causes the texture to affect the alpha value");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_emit", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_EMIT);
 +      RNA_def_property_ui_text(prop, "Emit", "Causes the texture to affect the emit value");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_translucency", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_TRANSLU);
 +      RNA_def_property_ui_text(prop, "Translucency", "Causes the texture to affect the translucency value");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_displacement", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_DISPLACE);
 +      RNA_def_property_ui_text(prop, "Displacement", "Let the texture displace the surface");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "map_warp", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_WARP);
 +      RNA_def_property_ui_text(prop, "Warp", "Let the texture warp texture coordinates of next channels");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "x_mapping", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "projx");
 +      RNA_def_property_enum_items(prop, prop_x_mapping_items);
 +      RNA_def_property_ui_text(prop, "X Mapping", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "y_mapping", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "projy");
 +      RNA_def_property_enum_items(prop, prop_y_mapping_items);
 +      RNA_def_property_ui_text(prop, "Y Mapping", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "z_mapping", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "projz");
 +      RNA_def_property_enum_items(prop, prop_z_mapping_items);
 +      RNA_def_property_ui_text(prop, "Z Mapping", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "mapping", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_items(prop, prop_mapping_items);
 +      RNA_def_property_ui_text(prop, "Mapping", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      /* XXX: pmapto, pmaptoneg */
 +
 +      prop= RNA_def_property(srna, "normal_map_space", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "normapspace");
 +      RNA_def_property_enum_items(prop, prop_normal_map_space_items);
 +      RNA_def_property_ui_text(prop, "Normal Map Space", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      /* XXX: MTex.which_output */
 +
 +      /* XXX: MTex.k */
 +
 +      prop= RNA_def_property(srna, "displacement_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "dispfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Displacement Factor", "Amount texture displaces the surface.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "warp_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "warpfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Warp Factor", "Amount texture affects texture coordinates of next channels.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "colorspec_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "colfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Specular Color Factor", "Amount texture affects specular color.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "colordiff_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "colfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Diffuse Color Factor", "Amount texture affects diffuse color.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "mirror_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "colfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Mirror Factor", "Amount texture affects mirror color.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "alpha_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "varfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Alpha Factor", "Amount texture affects alpha.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "diffuse_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "varfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Diffuse Factor", "Amount texture affects diffuse reflectivity.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "specular_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "varfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Specular Factor", "Amount texture affects specular reflectivity.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "emit_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "varfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Emit Factor", "Amount texture affects emission.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "hardness_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "varfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Hardness Factor", "Amount texture affects hardness.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "raymir_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "varfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Ray Mirror Factor", "Amount texture affects ray mirror.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "translucency_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "varfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Translucency Factor", "Amount texture affects translucency.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "ambient_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "varfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Ambient Factor", "Amount texture affects ambient.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_funcs(prop, "rna_MaterialTextureSlot_enabled_get", "rna_MaterialTextureSlot_enabled_set");
 +      RNA_def_property_ui_text(prop, "Enabled", "Enable this material texture slot.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "new_bump", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "texflag", MTEX_NEW_BUMP);
 +      RNA_def_property_ui_text(prop, "New Bump", "Use new, corrected bump mapping code (backwards compatibility option).");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +}
 +
 +static void rna_def_material_colors(StructRNA *srna)
 +{
 +      PropertyRNA *prop;
 +      
 +      static EnumPropertyItem prop_ramp_blend_diffuse_items[] = {
 +              {MA_RAMP_BLEND, "MIX", 0, "Mix", ""},
 +              {MA_RAMP_ADD, "ADD", 0, "Add", ""},
 +              {MA_RAMP_MULT, "MULTIPLY", 0, "Multiply", ""},
 +              {MA_RAMP_SUB, "SUBTRACT", 0, "Subtract", ""},
 +              {MA_RAMP_SCREEN, "SCREEN", 0, "Screen", ""},
 +              {MA_RAMP_DIV, "DIVIDE", 0, "Divide", ""},
 +              {MA_RAMP_DIFF, "DIFFERENCE", 0, "Difference", ""},
 +              {MA_RAMP_DARK, "DARKEN", 0, "Darken", ""},
 +              {MA_RAMP_LIGHT, "LIGHTEN", 0, "Lighten", ""},
 +              {MA_RAMP_OVERLAY, "OVERLAY", 0, "Overlay", ""},
 +              {MA_RAMP_DODGE, "DODGE", 0, "Dodge", ""},
 +              {MA_RAMP_BURN, "BURN", 0, "Burn", ""},
 +              {MA_RAMP_HUE, "HUE", 0, "Hue", ""},
 +              {MA_RAMP_SAT, "SATURATION", 0, "Saturation", ""},
 +              {MA_RAMP_VAL, "VALUE", 0, "Value", ""},
 +              {MA_RAMP_COLOR, "COLOR", 0, "Color", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      static EnumPropertyItem prop_ramp_input_items[] = {
 +              {MA_RAMP_IN_SHADER, "SHADER", 0, "Shader", ""},
 +              {MA_RAMP_IN_ENERGY, "ENERGY", 0, "Energy", ""},
 +              {MA_RAMP_IN_NOR, "NORMAL", 0, "Normal", ""},
 +              {MA_RAMP_IN_RESULT, "RESULT", 0, "Result", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      prop= RNA_def_property(srna, "diffuse_color", PROP_FLOAT, PROP_COLOR);
 +      RNA_def_property_float_sdna(prop, NULL, "r");
 +      RNA_def_property_array(prop, 3);
 +      RNA_def_property_ui_text(prop, "Diffuse Color", "");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING_DRAW, NULL);
 +      
 +      prop= RNA_def_property(srna, "specular_color", PROP_FLOAT, PROP_COLOR);
 +      RNA_def_property_float_sdna(prop, NULL, "specr");
 +      RNA_def_property_array(prop, 3);
 +      RNA_def_property_ui_text(prop, "Specular Color", "Specular color of the material.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING_DRAW, NULL);
 +      
 +      prop= RNA_def_property(srna, "mirror_color", PROP_FLOAT, PROP_COLOR);
 +      RNA_def_property_float_sdna(prop, NULL, "mirr");
 +      RNA_def_property_array(prop, 3);
 +      RNA_def_property_ui_text(prop, "Mirror Color", "Mirror color of the material.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Alpha", "Alpha transparency of the material.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING_DRAW, NULL);
 +      
 +      /* Color bands */
 +      prop= RNA_def_property(srna, "use_diffuse_ramp", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_RAMP_COL);
 +      RNA_def_property_boolean_funcs(prop, NULL, "rna_Material_use_diffuse_ramp_set");
 +      RNA_def_property_ui_text(prop, "Use Diffuse Ramp", "Toggle diffuse ramp operations.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING_DRAW, NULL);
 +
 +      prop= RNA_def_property(srna, "diffuse_ramp", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "ramp_col");
 +      RNA_def_property_struct_type(prop, "ColorRamp");
 +      RNA_def_property_ui_text(prop, "Diffuse Ramp", "Color ramp used to affect diffuse shading.");
 +
 +      prop= RNA_def_property(srna, "use_specular_ramp", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_RAMP_SPEC);
 +      RNA_def_property_boolean_funcs(prop, NULL, "rna_Material_use_specular_ramp_set");
 +      RNA_def_property_ui_text(prop, "Use Specular Ramp", "Toggle specular ramp operations.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING_DRAW, NULL);
 +
 +      prop= RNA_def_property(srna, "specular_ramp", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "ramp_spec");
 +      RNA_def_property_struct_type(prop, "ColorRamp");
 +      RNA_def_property_ui_text(prop, "Specular Ramp", "Color ramp used to affect specular shading.");
 +      
 +      prop= RNA_def_property(srna, "diffuse_ramp_blend", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "rampblend_col");
 +      RNA_def_property_enum_items(prop, prop_ramp_blend_diffuse_items);
 +      RNA_def_property_ui_text(prop, "Diffuse Ramp Blend", "");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING_DRAW, NULL);
 +      
 +      prop= RNA_def_property(srna, "specular_ramp_blend", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "rampblend_spec");
 +      RNA_def_property_enum_items(prop, prop_ramp_blend_diffuse_items);
 +      RNA_def_property_ui_text(prop, "Diffuse Ramp Blend", "");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING_DRAW, NULL);
 +
 +      prop= RNA_def_property(srna, "diffuse_ramp_input", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "rampin_col");
 +      RNA_def_property_enum_items(prop, prop_ramp_input_items);
 +      RNA_def_property_ui_text(prop, "Diffuse Ramp Input", "");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "specular_ramp_input", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "rampin_spec");
 +      RNA_def_property_enum_items(prop, prop_ramp_input_items);
 +      RNA_def_property_ui_text(prop, "Specular Ramp Input", "");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +}
 +
 +static void rna_def_material_diffuse(StructRNA *srna)
 +{
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_diff_shader_items[] = {
 +              {MA_DIFF_LAMBERT, "LAMBERT", 0, "Lambert", ""},
 +              {MA_DIFF_ORENNAYAR, "OREN_NAYAR", 0, "Oren-Nayar", ""},
 +              {MA_DIFF_TOON, "TOON", 0, "Toon", ""},
 +              {MA_DIFF_MINNAERT, "MINNAERT", 0, "Minnaert", ""},
 +              {MA_DIFF_FRESNEL, "FRESNEL", 0, "Fresnel", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +      
 +      prop= RNA_def_property(srna, "diffuse_shader", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "diff_shader");
 +      RNA_def_property_enum_items(prop, prop_diff_shader_items);
 +      RNA_def_property_ui_text(prop, "Diffuse Shader Model", "");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "diffuse_reflection", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "ref");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Diffuse Reflection", "Amount of diffuse reflection.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING_DRAW, NULL);
 +      
 +      prop= RNA_def_property(srna, "roughness", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.0f, 3.14f);
 +      RNA_def_property_ui_text(prop, "Roughness", "Oren-Nayar Roughness");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "diffuse_toon_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "param[0]");
 +      RNA_def_property_range(prop, 0.0f, 3.14f);
 +      RNA_def_property_ui_text(prop, "Diffuse Toon Size", "Size of diffuse toon area.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "diffuse_toon_smooth", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "param[1]");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Diffuse Toon Smooth", "Smoothness of diffuse toon area.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "diffuse_fresnel", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "param[1]");
 +      RNA_def_property_range(prop, 0.0f, 5.0f);
 +      RNA_def_property_ui_text(prop, "Diffuse Fresnel", "Power of Fresnel.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "diffuse_fresnel_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "param[0]");
 +      RNA_def_property_range(prop, 0.0f, 5.0f);
 +      RNA_def_property_ui_text(prop, "Diffuse Fresnel Factor", "Blending factor of Frensel.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "darkness", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.0f, 2.0f);
 +      RNA_def_property_ui_text(prop, "Darkness", "Minnaert darkness.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +}
 +
 +static void rna_def_material_raymirror(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_fadeto_mir_items[] = {
 +              {MA_RAYMIR_FADETOSKY, "FADE_TO_SKY", 0, "Sky", ""},
 +              {MA_RAYMIR_FADETOMAT, "FADE_TO_MATERIAL", 0, "Material", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "MaterialRaytraceMirror", NULL);
 +      RNA_def_struct_sdna(srna, "Material");
 +      RNA_def_struct_nested(brna, srna, "Material");
 +      RNA_def_struct_ui_text(srna, "Material Raytrace Mirror", "Raytraced reflection settings for a Material datablock.");
 +
 +      prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_RAYMIRROR); /* use bitflags */
 +      RNA_def_property_ui_text(prop, "Enabled", "Enable raytraced reflections.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +              
 +      prop= RNA_def_property(srna, "reflect", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "ray_mirror");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Reflect", "Sets the amount mirror reflection for raytrace.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "fresnel", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "fresnel_mir");
 +      RNA_def_property_range(prop, 0.0f, 5.0f);
 +      RNA_def_property_ui_text(prop, "Fresnel", "Power of Fresnel for mirror reflection.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "fresnel_fac", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "fresnel_mir_i");
 +      RNA_def_property_range(prop, 0.0f, 5.0f);
 +      RNA_def_property_ui_text(prop, "Fresnel Factor", "Blending factor for Fresnel.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "gloss", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "gloss_mir");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Gloss", "The shininess of the reflection. Values < 1.0 give diffuse, blurry reflections.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "gloss_anisotropic", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "aniso_gloss_mir");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Gloss Anisotropy", "The shape of the reflection, from 0.0 (circular) to 1.0 (fully stretched along the tangent.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +              
 +      prop= RNA_def_property(srna, "gloss_samples", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "samp_gloss_mir");
 +      RNA_def_property_range(prop, 0, 1024);
 +      RNA_def_property_ui_text(prop, "Gloss Samples", "Number of cone samples averaged for blurry reflections.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "gloss_threshold", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "adapt_thresh_mir");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Gloss Threshold", "Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "depth", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "ray_depth");
 +      RNA_def_property_range(prop, 0, 10);
 +      RNA_def_property_ui_text(prop, "Depth", "Maximum allowed number of light inter-reflections.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "distance", PROP_FLOAT, PROP_DISTANCE);
 +      RNA_def_property_float_sdna(prop, NULL, "dist_mir");
 +      RNA_def_property_range(prop, 0.0f, 10000.0f);
 +      RNA_def_property_ui_text(prop, "Maximum Distance", "Maximum distance of reflected rays. Reflections further than this range fade to sky color or material color.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "fade_to", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "fadeto_mir");
 +      RNA_def_property_enum_items(prop, prop_fadeto_mir_items);
 +      RNA_def_property_ui_text(prop, "Fade-out Color", "The color that rays with no intersection within the Max Distance take. Material color can be best for indoor scenes, sky color for outdoor.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +}
 +
 +static void rna_def_material_raytra(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      srna= RNA_def_struct(brna, "MaterialRaytraceTransparency", NULL);
 +      RNA_def_struct_sdna(srna, "Material");
 +      RNA_def_struct_nested(brna, srna, "Material");
 +      RNA_def_struct_ui_text(srna, "Material Raytrace Transparency", "Raytraced refraction settings for a Material datablock.");
 +
 +      prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_RAYTRANSP); /* use bitflags */
 +      RNA_def_property_ui_text(prop, "Enabled", "Enables raytracing for transparent refraction rendering.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "ior", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "ang");
 +      RNA_def_property_range(prop, 1.0f, 3.0f);
 +      RNA_def_property_ui_text(prop, "IOR", "Sets angular index of refraction for raytraced refraction.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "fresnel", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "fresnel_tra");
 +      RNA_def_property_range(prop, 0.0f, 5.0f);
 +      RNA_def_property_ui_text(prop, "Fresnel", "Power of Fresnel for transparency (Ray or ZTransp).");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "fresnel_fac", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "fresnel_tra_i");
 +      RNA_def_property_range(prop, 1.0f, 5.0f);
 +      RNA_def_property_ui_text(prop, "Fresnel Factor", "Blending factor for Fresnel.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "gloss", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "gloss_tra");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Gloss", "The clarity of the refraction. Values < 1.0 give diffuse, blurry refractions.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "gloss_samples", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "samp_gloss_tra");
 +      RNA_def_property_range(prop, 0, 1024);
 +      RNA_def_property_ui_text(prop, "Gloss Samples", "Number of cone samples averaged for blurry refractions.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "gloss_threshold", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "adapt_thresh_tra");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Gloss Threshold", "Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "depth", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "ray_depth_tra");
 +      RNA_def_property_range(prop, 0, 10);
 +      RNA_def_property_ui_text(prop, "Depth", "Maximum allowed number of light inter-refractions.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "filter", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "filter");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Filter", "Amount to blend in the material's diffuse color in raytraced transparency (simulating absorption).");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "limit", PROP_FLOAT, PROP_DISTANCE);
 +      RNA_def_property_float_sdna(prop, NULL, "tx_limit");
 +      RNA_def_property_range(prop, 0.0f, 100.0f);
 +      RNA_def_property_ui_text(prop, "Limit", "Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled).");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "tx_falloff");
 +      RNA_def_property_range(prop, 0.1f, 10.0f);
 +      RNA_def_property_ui_text(prop, "Falloff", "Falloff power for transmissivity filter effect (1.0 is linear).");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "specular_opacity", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "spectra");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Specular Opacity", "Makes specular areas opaque on transparent materials.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +}
 +
++static void rna_def_material_volume(BlenderRNA *brna)
++{
++      StructRNA *srna;
++      PropertyRNA *prop;
++
++      static EnumPropertyItem prop_scattering_items[] = {
++              {MA_VOL_SHADE_NONE, "NONE", 0, "None", ""},
++              {MA_VOL_SHADE_SINGLE, "SINGLE", 0, "Single", ""},
++              {MA_VOL_SHADE_MULTIPLE, "MULTIPLE", 0, "Multiple", ""},
++              {MA_VOL_SHADE_SINGLEPLUSMULTIPLE, "SINGLE_PLUS_MULTIPLE", 0, "Single + Multiple", ""},
++              {0, NULL, 0, NULL, NULL}};
++
++      static EnumPropertyItem prop_stepsize_items[] = {
++              {MA_VOL_STEP_RANDOMIZED, "RANDOMIZED", 0, "Randomized", ""},
++              {MA_VOL_STEP_CONSTANT, "CONSTANT", 0, "Constant", ""},
++              //{MA_VOL_STEP_ADAPTIVE, "ADAPTIVE", 0, "Adaptive", ""},
++              {0, NULL, 0, NULL, NULL}};
++              
++      static EnumPropertyItem prop_phasefunction_items[] = {
++              {MA_VOL_PH_ISOTROPIC, "ISOTROPIC", 0, "Isotropic", ""},
++              {MA_VOL_PH_MIEHAZY, "MIE_HAZY", 0, "Mie Hazy", ""},
++              {MA_VOL_PH_MIEMURKY, "MIE_MURKY", 0, "Mie Murky", ""},
++              {MA_VOL_PH_RAYLEIGH, "RAYLEIGH", 0, "Rayleigh", ""},
++              {MA_VOL_PH_HG, "HENYEY-GREENSTEIN", 0, "Henyey-Greenstein", ""},
++              {MA_VOL_PH_SCHLICK, "SCHLICK", 0, "Schlick", ""},
++              {0, NULL, 0, NULL, NULL}};
++
++      srna= RNA_def_struct(brna, "MaterialVolume", NULL);
++      RNA_def_struct_sdna(srna, "VolumeSettings");
++      RNA_def_struct_nested(brna, srna, "Material");
++      RNA_def_struct_ui_text(srna, "Material Volume", "Volume rendering settings for a Material datablock.");
++      
++      prop= RNA_def_property(srna, "step_calculation", PROP_ENUM, PROP_NONE);
++      RNA_def_property_enum_sdna(prop, NULL, "stepsize_type");
++      RNA_def_property_enum_items(prop, prop_stepsize_items);
++      RNA_def_property_ui_text(prop, "Step Calculation", "Method of calculating the steps through the volume");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "step_size", PROP_FLOAT, PROP_NONE);
++      RNA_def_property_float_sdna(prop, NULL, "stepsize");
++      RNA_def_property_range(prop, 0.0f, FLT_MAX);
++      RNA_def_property_ui_text(prop, "Step Size", "Distance between subsequent volume depth samples.");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "shading_step_size", PROP_FLOAT, PROP_NONE);
++      RNA_def_property_float_sdna(prop, NULL, "shade_stepsize");
++      RNA_def_property_range(prop, 0.0f, FLT_MAX);
++      RNA_def_property_ui_text(prop, "Shading Step Size", "Distance between subsequent volume shading samples.");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "scattering_mode", PROP_ENUM, PROP_NONE);
++      RNA_def_property_enum_sdna(prop, NULL, "shade_type");
++      RNA_def_property_enum_items(prop, prop_scattering_items);
++      RNA_def_property_ui_text(prop, "Scattering Mode", "Method of shading, attenuating, and scattering light through the volume");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "light_cache", PROP_BOOLEAN, PROP_NONE);
++      RNA_def_property_boolean_sdna(prop, NULL, "shadeflag", MA_VOL_PRECACHESHADING); /* use bitflags */
++      RNA_def_property_ui_text(prop, "Light Cache", "Pre-calculate the shading information into a voxel grid, speeds up shading at slightly less accuracy");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "cache_resolution", PROP_INT, PROP_NONE);
++      RNA_def_property_int_sdna(prop, NULL, "precache_resolution");
++      RNA_def_property_range(prop, 0, 1024);
++      RNA_def_property_ui_text(prop, "Resolution", "Resolution of the voxel grid, low resolutions are faster, high resolutions use more memory.");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "ms_diffusion", PROP_FLOAT, PROP_NONE);
++      RNA_def_property_float_sdna(prop, NULL, "ms_diff");
++      RNA_def_property_range(prop, 0.0f, FLT_MAX);
++      RNA_def_property_ui_text(prop, "Diffusion", "Diffusion factor, the strength of the blurring effect");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "ms_spread", PROP_INT, PROP_NONE);
++      RNA_def_property_int_sdna(prop, NULL, "ms_steps");
++      RNA_def_property_range(prop, 0, 1024);
++      RNA_def_property_ui_text(prop, "Spread", "Simulation steps, the effective distance over which the light is diffused");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "ms_intensity", PROP_FLOAT, PROP_NONE);
++      RNA_def_property_float_sdna(prop, NULL, "ms_intensity");
++      RNA_def_property_range(prop, 0.0f, FLT_MAX);
++      RNA_def_property_ui_text(prop, "Intensity", "Multiplier for multiple scattered light energy");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "depth_cutoff", PROP_FLOAT, PROP_NONE);
++      RNA_def_property_float_sdna(prop, NULL, "depth_cutoff");
++      RNA_def_property_range(prop, 0.0f, 1.0f);
++      RNA_def_property_ui_text(prop, "Depth Cutoff", "Stop ray marching early if transmission drops below this luminance - higher values give speedups in dense volumes at the expense of accuracy.");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "density_scale", PROP_FLOAT, PROP_NONE);
++      RNA_def_property_float_sdna(prop, NULL, "density_scale");
++      RNA_def_property_range(prop, 0.0f, FLT_MAX);
++      RNA_def_property_ui_text(prop, "Density Scale", "Multiplier for the material's density");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "absorption", PROP_FLOAT, PROP_NONE);
++      RNA_def_property_float_sdna(prop, NULL, "absorption");
++      RNA_def_property_range(prop, 0.0f, FLT_MAX);
++      RNA_def_property_ui_text(prop, "Absorption", "Amount of light that gets absorbed by the volume - higher values mean light travels less distance");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "absorption_color", PROP_FLOAT, PROP_COLOR);
++      RNA_def_property_float_sdna(prop, NULL, "absorption_col");
++      RNA_def_property_array(prop, 3);
++      RNA_def_property_ui_text(prop, "Absorption Color", "");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING_DRAW, NULL);
++      
++      prop= RNA_def_property(srna, "scattering", PROP_FLOAT, PROP_NONE);
++      RNA_def_property_float_sdna(prop, NULL, "scattering");
++      RNA_def_property_range(prop, 0.0f, FLT_MAX);
++      RNA_def_property_ui_text(prop, "Scattering", "Amount of light that gets scattered by the volume - values > 1.0 are non-physical");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
++      RNA_def_property_boolean_sdna(prop, NULL, "shadeflag", MA_VOL_USEALPHA); /* use bitflags */
++      RNA_def_property_ui_text(prop, "Use Alpha", "Temp method for getting a usable alpha channel");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "phase_function", PROP_ENUM, PROP_NONE);
++      RNA_def_property_enum_sdna(prop, NULL, "phasefunc_type");
++      RNA_def_property_enum_items(prop, prop_phasefunction_items);
++      RNA_def_property_ui_text(prop, "Phase Function", "Isotropic/Anisotropic scattering");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      prop= RNA_def_property(srna, "asymmetry", PROP_FLOAT, PROP_NONE);
++      RNA_def_property_float_sdna(prop, NULL, "phasefunc_g");
++      RNA_def_property_range(prop, -1.0f, 1.0f);
++      RNA_def_property_ui_text(prop, "Asymmetry", "Continuum between forward scattering and back scattering");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      
++      /*
++      prop= RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
++      RNA_def_property_int_sdna(prop, NULL, "samp_gloss_mir");
++      RNA_def_property_range(prop, 0, 1024);
++      RNA_def_property_ui_text(prop, "Gloss Samples", "Number of cone samples averaged for blurry reflections.");
++      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
++      */
++}
++
++
 +static void rna_def_material_halo(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      srna= RNA_def_struct(brna, "MaterialHalo", NULL);
 +      RNA_def_struct_sdna(srna, "Material");
 +      RNA_def_struct_nested(brna, srna, "Material");
 +      RNA_def_struct_ui_text(srna, "Material Halo", "Halo particle effect settings for a Material datablock.");
 +
 +      prop= RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "hasize");
 +      RNA_def_property_range(prop, 0.0f, 100.0f);
 +      RNA_def_property_ui_text(prop, "Size", "Sets the dimension of the halo.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "hardness", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "har");
 +      RNA_def_property_range(prop, 0, 127);
 +      RNA_def_property_ui_text(prop, "Hardness", "Sets the hardness of the halo.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "add", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "add");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Add", "Sets the strength of the add effect.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "rings", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "ringc");
 +      RNA_def_property_range(prop, 0, 24);
 +      RNA_def_property_ui_text(prop, "Rings", "Sets the number of rings rendered over the halo.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "line_number", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "linec");
 +      RNA_def_property_range(prop, 0, 250);
 +      RNA_def_property_ui_text(prop, "Line Number", "Sets the number of star shaped lines rendered over the halo.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "star_tips", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "starc");
 +      RNA_def_property_range(prop, 3, 50);
 +      RNA_def_property_ui_text(prop, "Star Tips", "Sets the number of points on the star shaped halo.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "seed", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "seed1");
 +      RNA_def_property_range(prop, 0, 255);
 +      RNA_def_property_ui_text(prop, "Seed", "Randomizes ring dimension and line location.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "flare_mode", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_FLARE); /* use bitflags */
 +      RNA_def_property_ui_text(prop, "Flare", "Renders halo as a lensflare.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "flare_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "flaresize");
 +      RNA_def_property_range(prop, 0.1f, 25.0f);
 +      RNA_def_property_ui_text(prop, "Flare Size", "Sets the factor by which the flare is larger than the halo.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "flare_subsize", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "subsize");
 +      RNA_def_property_range(prop, 0.1f, 25.0f);
 +      RNA_def_property_ui_text(prop, "Flare Subsize", "Sets the dimension of the subflares, dots and circles.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "flare_boost", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "flareboost");
 +      RNA_def_property_range(prop, 0.1f, 10.0f);
 +      RNA_def_property_ui_text(prop, "Flare Boost", "Gives the flare extra strength.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "flare_seed", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "seed2");
 +      RNA_def_property_range(prop, 0, 255);
 +      RNA_def_property_ui_text(prop, "Flare Seed", "Specifies an offset in the flare seed table.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "flares_sub", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "flarec");
 +      RNA_def_property_range(prop, 1, 32);
 +      RNA_def_property_ui_text(prop, "Flares Sub", "Sets the number of subflares.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "ring", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_RINGS);
 +      RNA_def_property_ui_text(prop, "Rings", "Renders rings over halo.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "lines", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_LINES);
 +      RNA_def_property_ui_text(prop, "Lines", "Renders star shaped lines over halo.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "star", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_STAR);
 +      RNA_def_property_ui_text(prop, "Star", "Renders halo as a star.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "use_texture", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALOTEX);
 +      RNA_def_property_ui_text(prop, "Use Texture", "Gives halo a texture.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "use_vertex_normal", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALOPUNO);
 +      RNA_def_property_ui_text(prop, "Use Vertex Normal", "Uses the vertex normal to specify the dimension of the halo.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "xalpha", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_XALPHA);
 +      RNA_def_property_ui_text(prop, "Extreme Alpha", "Uses extreme alpha.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "shaded", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_SHADE);
 +      RNA_def_property_ui_text(prop, "Shaded", "Lets halo receive light and shadows from external objects.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "soft", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_SOFT);
 +      RNA_def_property_ui_text(prop, "Soft", "Softens the edges of halos at intersections with other geometry.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +}
 +
 +static void rna_def_material_sss(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      srna= RNA_def_struct(brna, "MaterialSubsurfaceScattering", NULL);
 +      RNA_def_struct_sdna(srna, "Material");
 +      RNA_def_struct_nested(brna, srna, "Material");
 +      RNA_def_struct_ui_text(srna, "Material Subsurface Scattering", "Diffuse subsurface scattering settings for a Material datablock.");
 +
 +      prop= RNA_def_property(srna, "radius", PROP_FLOAT, PROP_RGB|PROP_UNIT_LENGTH);
 +      RNA_def_property_float_sdna(prop, NULL, "sss_radius");
 +      RNA_def_property_range(prop, 0.001, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.001, 10000, 1, 3);
 +      RNA_def_property_ui_text(prop, "Radius", "Mean red/green/blue scattering path length.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
 +      RNA_def_property_float_sdna(prop, NULL, "sss_col");
 +      RNA_def_property_ui_text(prop, "Color", "Scattering color.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "error_tolerance", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "sss_error");
 +      RNA_def_property_ui_range(prop, 0.0001, 10, 1, 3);
 +      RNA_def_property_ui_text(prop, "Error Tolerance", "Error tolerance (low values are slower and higher quality).");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "sss_scale");
 +      RNA_def_property_ui_range(prop, 0.001, 1000, 1, 3);
 +      RNA_def_property_ui_text(prop, "Scale", "Object scale factor.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "ior", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "sss_ior");
 +      RNA_def_property_ui_range(prop, 0.1, 2, 1, 3);
 +      RNA_def_property_ui_text(prop, "IOR", "Index of refraction (higher values are denser).");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "color_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "sss_colfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Color Factor", "Blend factor for SSS colors.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "texture_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "sss_texfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Texture Factor", "Texture scatting blend factor.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "front", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "sss_front");
 +      RNA_def_property_range(prop, 0, 2);
 +      RNA_def_property_ui_text(prop, "Front", "Front scattering weight.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "back", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "sss_back");
 +      RNA_def_property_range(prop, 0, 10);
 +      RNA_def_property_ui_text(prop, "Back", "Back scattering weight.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "sss_flag", MA_DIFF_SSS);
 +      RNA_def_property_ui_text(prop, "Enabled", "Enable diffuse subsurface scatting effects in a material.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +}
 +
 +void rna_def_material_specularity(StructRNA *srna)
 +{
 +      PropertyRNA *prop;
 +      
 +      static EnumPropertyItem prop_specular_shader_items[] = {
 +              {MA_SPEC_COOKTORR, "COOKTORR", 0, "CookTorr", ""},
 +              {MA_SPEC_PHONG, "PHONG", 0, "Phong", ""},
 +              {MA_SPEC_BLINN, "BLINN", 0, "Blinn", ""},
 +              {MA_SPEC_TOON, "TOON", 0, "Toon", ""},
 +              {MA_SPEC_WARDISO, "WARDISO", 0, "WardIso", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +      
 +      prop= RNA_def_property(srna, "specular_shader", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "spec_shader");
 +      RNA_def_property_enum_items(prop, prop_specular_shader_items);
 +      RNA_def_property_ui_text(prop, "Specular Shader Model", "");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "specular_reflection", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "spec");
 +      RNA_def_property_range(prop, 0, 1);
 +      RNA_def_property_ui_text(prop, "Specularity Intensity", "");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      /* NOTE: "har", "param", etc are used for multiple purposes depending on
 +       * settings. This should be fixed in DNA once, for RNA we just expose them
 +       * multiple times, which may give somewhat strange changes in the outliner,
 +       * but in the UI they are never visible at the same time. */
 +
 +      prop= RNA_def_property(srna, "specular_hardness", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "har");
 +      RNA_def_property_range(prop, 1, 511);
 +      RNA_def_property_ui_text(prop, "Specular Hardness", "");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "specular_ior", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "refrac");
 +      RNA_def_property_range(prop, 1, 10);
 +      RNA_def_property_ui_text(prop, "Specular IOR", "");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "specular_toon_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "param[2]");
 +      RNA_def_property_range(prop, 0.0f, 1.53f);
 +      RNA_def_property_ui_text(prop, "Specular Toon Size", "Size of specular toon area.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "specular_toon_smooth", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "param[3]");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Specular Toon Smooth", "Ssmoothness of specular toon area.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "specular_slope", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "rms");
 +      RNA_def_property_range(prop, 0, 0.4);
 +      RNA_def_property_ui_text(prop, "Specular Slope", "The standard deviation of surface slope.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +}
 +
 +void rna_def_material_strand(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      srna= RNA_def_struct(brna, "MaterialStrand", NULL);
 +      RNA_def_struct_sdna(srna, "Material");
 +      RNA_def_struct_nested(brna, srna, "Material");
 +      RNA_def_struct_ui_text(srna, "Material Strand", "Strand settings for a Material datablock.");
 +
 +      prop= RNA_def_property(srna, "tangent_shading", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_TANGENT_STR);
 +      RNA_def_property_ui_text(prop, "Tangent Shading", "Uses direction of strands as normal for tangent-shading.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "surface_diffuse", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_STR_SURFDIFF);
 +      RNA_def_property_ui_text(prop, "Surface Diffuse", "Make diffuse shading more similar to shading the surface.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "blend_distance", PROP_FLOAT, PROP_DISTANCE);
 +      RNA_def_property_float_sdna(prop, NULL, "strand_surfnor");
 +      RNA_def_property_range(prop, 0, 10);
 +      RNA_def_property_ui_text(prop, "Blend Distance", "Worldspace distance over which to blend in the surface normal.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "blender_units", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_STR_B_UNITS);
 +      RNA_def_property_ui_text(prop, "Blender Units", "Use Blender units for widths instead of pixels.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "start_size", PROP_FLOAT, PROP_UNSIGNED);
 +      RNA_def_property_float_sdna(prop, NULL, "strand_sta");
 +      RNA_def_property_float_funcs(prop, NULL, NULL, "rna_MaterialStrand_start_size_range");
 +      RNA_def_property_ui_text(prop, "Start Size", "Start size of strands in pixels Blender units.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "end_size", PROP_FLOAT, PROP_UNSIGNED);
 +      RNA_def_property_float_sdna(prop, NULL, "strand_end");
 +      RNA_def_property_float_funcs(prop, NULL, NULL, "rna_MaterialStrand_end_size_range");
 +      RNA_def_property_ui_text(prop, "End Size", "Start size of strands in pixels or Blender units.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "min_size", PROP_FLOAT, PROP_UNSIGNED);
 +      RNA_def_property_float_sdna(prop, NULL, "strand_min");
 +      RNA_def_property_range(prop, 0.001, 10);
 +      RNA_def_property_ui_text(prop, "Minimum Size", "Minimum size of strands in pixels.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "shape", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "strand_ease");
 +      RNA_def_property_range(prop, -0.9, 0.9);
 +      RNA_def_property_ui_text(prop, "Shape", "Positive values make strands rounder, negative makes strands spiky.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "width_fade", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "strand_widthfade");
 +      RNA_def_property_range(prop, 0, 2);
 +      RNA_def_property_ui_text(prop, "Width Fade", "Transparency along the width of the strand.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
 +      RNA_def_property_string_sdna(prop, NULL, "strand_uvname");
 +      RNA_def_property_ui_text(prop, "UV Layer", "Name of UV layer to override.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +}
 +
 +void rna_def_material_physics(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +      
 +      srna= RNA_def_struct(brna, "MaterialPhysics", NULL);
 +      RNA_def_struct_sdna(srna, "Material");
 +      RNA_def_struct_nested(brna, srna, "Material");
 +      RNA_def_struct_ui_text(srna, "Material Physics", "Physics settings for a Material datablock.");
 +      
 +      prop= RNA_def_property(srna, "align_to_normal", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_FH_NOR);
 +      RNA_def_property_ui_text(prop, "Align to Normal", "Align dynamic game objects along the surface normal, when inside the physics distance area");
 +      
 +      prop= RNA_def_property(srna, "friction", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "friction");
 +      RNA_def_property_range(prop, 0, 100);
 +      RNA_def_property_ui_text(prop, "Friction", "Coulomb friction coeffecient, when inside the physics distance area");
 +
 +      prop= RNA_def_property(srna, "force", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "fh");
 +      RNA_def_property_range(prop, 0, 1);
 +      RNA_def_property_ui_text(prop, "Force", "Upward spring force, when inside the physics distance area");
 +      
 +      prop= RNA_def_property(srna, "elasticity", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "reflect");
 +      RNA_def_property_range(prop, 0, 1);
 +      RNA_def_property_ui_text(prop, "Elasticity", "Elasticity of collisions");
 +      
 +      prop= RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "fhdist");
 +      RNA_def_property_range(prop, 0, 20);
 +      RNA_def_property_ui_text(prop, "Distance", "Distance of the physics area");
 +      
 +      prop= RNA_def_property(srna, "damp", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "xyfrict");
 +      RNA_def_property_range(prop, 0, 1);
 +      RNA_def_property_ui_text(prop, "Damping", "Damping of the spring force, when inside the physics distance area");
 +}
 +
 +void RNA_def_material(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_type_items[] = {
 +              {MA_TYPE_SURFACE, "SURFACE", 0, "Surface", "Render object as a surface."},
 +              {MA_TYPE_WIRE, "WIRE", 0, "Wire", "Render the edges of faces as wires (not supported in ray tracing)."},
++              {MA_TYPE_VOLUME, "VOLUME", 0, "Volume", "Render object as a volume."},
 +              {MA_TYPE_HALO, "HALO", 0, "Halo", "Render object as halo particles."},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "Material", "ID");
 +      RNA_def_struct_ui_text(srna, "Material", "Material datablock to defined the appearance of geometric objects for rendering.");
 +      RNA_def_struct_ui_icon(srna, ICON_MATERIAL_DATA);
 +      
 +      prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "material_type");
 +      RNA_def_property_enum_items(prop, prop_type_items);
 +      RNA_def_property_ui_text(prop, "Type", "Material type defining how the object is rendered.");
 +      RNA_def_property_enum_funcs(prop, NULL, "rna_Material_type_set", NULL);
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING_DRAW, NULL);
 +      
 +      prop= RNA_def_property(srna, "ambient", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "amb");
 +      RNA_def_property_range(prop, 0, 1);
 +      RNA_def_property_ui_text(prop, "Ambient", "Amount of global ambient color the material receives.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "emit", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0, 2);
 +      RNA_def_property_ui_text(prop, "Emit", "Amount of light to emit.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "translucency", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0, 1);
 +      RNA_def_property_ui_text(prop, "Translucency", "Amount of diffuse shading on the back side.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +              
 +      prop= RNA_def_property(srna, "cubic", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "shade_flag", MA_CUBIC);
 +      RNA_def_property_ui_text(prop, "Cubic Interpolation", "Use cubic interpolation for diffuse values, for smoother transitions.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "object_color", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "shade_flag", MA_OBCOLOR);
 +      RNA_def_property_ui_text(prop, "Object Color", "Modulate the result with a per-object color.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "shadow_ray_bias", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "sbias");
 +      RNA_def_property_range(prop, 0, 0.25);
 +      RNA_def_property_ui_text(prop, "Shadow Ray Bias", "Shadow raytracing bias to prevent terminator problems on shadow boundary.");
 +
 +      prop= RNA_def_property(srna, "shadow_buffer_bias", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "lbias");
 +      RNA_def_property_range(prop, 0, 10);
 +      RNA_def_property_ui_text(prop, "Shadow Buffer Bias", "Factor to multiply shadow buffer bias with (0 is ignore.)");
 +
 +      prop= RNA_def_property(srna, "shadow_casting_alpha", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "shad_alpha");
 +      RNA_def_property_range(prop, 0.001, 1);
 +      RNA_def_property_ui_text(prop, "Shadow Casting Alpha", "Shadow casting alpha, only in use for Irregular Shadowbuffer.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "light_group", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "group");
 +      RNA_def_property_struct_type(prop, "Group");
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Light Group", "Limit lighting to lamps in this Group.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      /* flags */
 +      
 +      prop= RNA_def_property(srna, "light_group_exclusive", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_GROUP_NOLAY);
 +      RNA_def_property_ui_text(prop, "Light Group Exclusive", "Material uses the light group exclusively - these lamps are excluded from other scene lighting.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "traceable", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_TRACEBLE);
 +      RNA_def_property_ui_text(prop, "Traceable", "Include this material and geometry that uses it in ray tracing calculations.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "shadows", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_SHADOW);
 +      RNA_def_property_ui_text(prop, "Shadows", "Allows this material to receive shadows.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "shadeless", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_SHLESS);
 +      RNA_def_property_ui_text(prop, "Shadeless", "Makes this material insensitive to light or shadow.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "z_transparency", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_ZTRA);
 +      RNA_def_property_ui_text(prop, "Z Transparency", "Enable alpha buffer for transparent faces.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "vertex_color_light", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_VERTEXCOL);
 +      RNA_def_property_ui_text(prop, "Vertex Color Light", "Add vertex colors as additional lighting.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "vertex_color_paint", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_VERTEXCOLP);
 +      RNA_def_property_ui_text(prop, "Vertex Color Paint", "Replaces object base color with vertex colors (multiplies with 'texture face' face assigned textures).");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "invert_z", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_ZINV);
 +      RNA_def_property_ui_text(prop, "Invert Z Depth", "Renders material's faces with an inverted Z buffer (scanline only).");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "sky", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_ENV);
 +      RNA_def_property_ui_text(prop, "Sky", "Renders this material with zero alpha, with sky background in place (scanline only).");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "only_shadow", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_ONLYSHADOW);
 +      RNA_def_property_ui_text(prop, "Only Shadow", "Renders shadows as the material's alpha value, making materials transparent except for shadowed areas.");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "face_texture", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_FACETEXTURE);
 +      RNA_def_property_ui_text(prop, "Face Textures", "Replaces the object's base color with color from face assigned image textures");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "face_texture_alpha", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_FACETEXTURE_ALPHA);
 +      RNA_def_property_ui_text(prop, "Face Textures Alpha", "Replaces the object's base alpha value with alpha from face assigned image textures");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "cast_shadows_only", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_ONLYCAST);
 +      RNA_def_property_ui_text(prop, "Cast Shadows Only", "Makes objects with this material appear invisible, only casting shadows (not rendered).");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "exclude_mist", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_NOMIST);
 +      RNA_def_property_ui_text(prop, "Exclude Mist", "Excludes this material from mist effects (in world settings)");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "radiosity", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_RADIO);
 +      RNA_def_property_ui_text(prop, "Radiosity", "Include this material in radiosity calculations");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "transparent_shadows", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_SHADOW_TRA);
 +      RNA_def_property_ui_text(prop, "Transparent Shadows", "Allow this object to receive transparent shadows casted through other objects");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "ray_shadow_bias", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_RAYBIAS);
 +      RNA_def_property_ui_text(prop, "Ray Shadow Bias", "Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "full_oversampling", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_FULL_OSA);
 +      RNA_def_property_ui_text(prop, "Full Oversampling", "Force this material to render full shading/textures for all anti-aliasing samples");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +
 +      prop= RNA_def_property(srna, "cast_buffer_shadows", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_SHADBUF);
 +      RNA_def_property_ui_text(prop, "Cast Buffer Shadows", "Allow this material to cast shadows from shadow buffer lamps");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      prop= RNA_def_property(srna, "tangent_shading", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_TANGENT_V);
 +      RNA_def_property_ui_text(prop, "Tangent Shading", "Use the material's tangent vector instead of the normal for shading - for anisotropic shading effects");
 +      RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
 +      
 +      /* nested structs */
 +      prop= RNA_def_property(srna, "raytrace_mirror", PROP_POINTER, PROP_NEVER_NULL);
 +      RNA_def_property_struct_type(prop, "MaterialRaytraceMirror");
 +      RNA_def_property_pointer_funcs(prop, "rna_Material_mirror_get", NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Raytrace Mirror", "Raytraced reflection settings for the material.");
 +
 +      prop= RNA_def_property(srna, "raytrace_transparency", PROP_POINTER, PROP_NEVER_NULL);
 +      RNA_def_property_struct_type(prop, "MaterialRaytraceTransparency");
 +      RNA_def_property_pointer_funcs(prop, "rna_Material_transp_get", NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Raytrace Transparency", "Raytraced reflection settings for the material.");
 +
++      prop= RNA_def_property(srna, "volume", PROP_POINTER, PROP_NEVER_NULL);
++      RNA_def_property_pointer_sdna(prop, NULL, "vol");
++      RNA_def_property_struct_type(prop, "MaterialVolume");
++      RNA_def_property_ui_text(prop, "Volume", "Volume settings for the material.");
++
 +      prop= RNA_def_property(srna, "halo", PROP_POINTER, PROP_NEVER_NULL);
 +      RNA_def_property_struct_type(prop, "MaterialHalo");
 +      RNA_def_property_pointer_funcs(prop, "rna_Material_halo_get", NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Halo", "Halo settings for the material.");
 +
 +      prop= RNA_def_property(srna, "subsurface_scattering", PROP_POINTER, PROP_NEVER_NULL);
 +      RNA_def_property_struct_type(prop, "MaterialSubsurfaceScattering");
 +      RNA_def_property_pointer_funcs(prop, "rna_Material_sss_get", NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Subsurface Scattering", "Subsurface scattering settings for the material.");
 +
 +      prop= RNA_def_property(srna, "strand", PROP_POINTER, PROP_NEVER_NULL);
 +      RNA_def_property_struct_type(prop, "MaterialStrand");
 +      RNA_def_property_pointer_funcs(prop, "rna_Material_strand_get", NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Strand", "Strand settings for the material.");
 +      
 +      prop= RNA_def_property(srna, "physics", PROP_POINTER, PROP_NEVER_NULL);
 +      RNA_def_property_struct_type(prop, "MaterialPhysics");
 +      RNA_def_property_pointer_funcs(prop, "rna_Material_physics_get", NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Physics", "Game physics settings.");
 +
 +      /* nodetree */
 +      prop= RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
 +      RNA_def_property_ui_text(prop, "Node Tree", "Node tree for node based materials.");
 +
 +      /* common */
 +      rna_def_animdata_common(srna);
 +      rna_def_mtex_common(srna, "rna_Material_mtex_begin", "rna_Material_active_texture_get",
 +              "rna_Material_active_texture_set", "MaterialTextureSlot");
 +      
 +      rna_def_material_colors(srna);
 +      rna_def_material_diffuse(srna);
 +      rna_def_material_specularity(srna);
 +
 +      /* nested structs */
 +      rna_def_material_raymirror(brna);
 +      rna_def_material_raytra(brna);
++      rna_def_material_volume(brna);
 +      rna_def_material_halo(brna);
 +      rna_def_material_sss(brna);
 +      rna_def_material_mtex(brna);
 +      rna_def_material_strand(brna);
 +      rna_def_material_physics(brna);
 +}
 +
 +void rna_def_mtex_common(StructRNA *srna, const char *begin, const char *activeget, const char *activeset, const char *structname)
 +{
 +      PropertyRNA *prop;
 +
 +      /* mtex */
 +      prop= RNA_def_property(srna, "textures", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_struct_type(prop, structname);
 +      RNA_def_property_collection_funcs(prop, begin, "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_dereference_get", 0, 0, 0, 0, 0);
 +      RNA_def_property_ui_text(prop, "Textures", "Texture slots defining the mapping and influence of textures.");
 +
 +      prop= RNA_def_property(srna, "active_texture", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_struct_type(prop, "Texture");
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_pointer_funcs(prop, activeget, activeset, NULL);
 +      RNA_def_property_ui_text(prop, "Active Texture", "Active texture slot being displayed.");
 +
 +      prop= RNA_def_property(srna, "active_texture_index", PROP_INT, PROP_UNSIGNED);
 +      RNA_def_property_int_sdna(prop, NULL, "texact");
 +      RNA_def_property_range(prop, 0, MAX_MTEX-1);
 +      RNA_def_property_ui_text(prop, "Active Texture Index", "Index of active texture slot.");
 +}
 +
 +#endif
 +
 +
index 5c7fd5ece0e4df5cb2b1d1c4739f03ec3a4c2a22,0000000000000000000000000000000000000000..577b9de437523c0d82d484d092188b257393abdb
mode 100644,000000..100644
--- /dev/null
@@@ -1,1287 -1,0 +1,1539 @@@
 +/**
 + * $Id$
 + *
 + * ***** BEGIN GPL 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.
 + *
 + * 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.
 + *
 + * Contributor(s): Blender Foundation (2008).
 + *
 + * ***** END GPL LICENSE BLOCK *****
 + */
 +
 +#include <float.h>
 +#include <stdio.h>
 +#include <stdlib.h>
 +
 +#include "RNA_define.h"
 +#include "RNA_types.h"
 +
 +#include "rna_internal.h"
 +
 +#include "DNA_brush_types.h"
 +#include "DNA_lamp_types.h"
 +#include "DNA_material_types.h"
 +#include "DNA_texture_types.h"
 +#include "DNA_world_types.h"
 +
 +#include "WM_types.h"
 +
 +static EnumPropertyItem texture_filter_items[] = {
 +      {TXF_BOX, "BOX", 0, "Box", ""},
 +      {TXF_EWA, "EWA", 0, "EWA", ""},
 +      {TXF_FELINE, "FELINE", 0, "FELINE", ""},
 +      {TXF_AREA, "AREA", 0, "Area", ""},
 +      {TXF_SAT, "SAT", 0, "SAT (4x mem)", ""},
 +      {0, NULL, 0, NULL, NULL}};
 +
 +#ifdef RNA_RUNTIME
 +
 +#include "BKE_texture.h"
 +
 +StructRNA *rna_Texture_refine(struct PointerRNA *ptr)
 +{
 +      Tex *tex= (Tex*)ptr->data;
 +
 +      switch(tex->type) {
 +              case TEX_CLOUDS:
 +                      return &RNA_CloudsTexture;
 +              case TEX_WOOD:
 +                      return &RNA_WoodTexture;
 +              case TEX_MARBLE:
 +                      return &RNA_MarbleTexture;
 +              case TEX_MAGIC:
 +                      return &RNA_MagicTexture;
 +              case TEX_BLEND:
 +                      return &RNA_BlendTexture; 
 +              case TEX_STUCCI:
 +                      return &RNA_StucciTexture;
 +              case TEX_NOISE:
 +                      return &RNA_NoiseTexture;
 +              case TEX_IMAGE:
 +                      return &RNA_ImageTexture;
 +              case TEX_PLUGIN:
 +                      return &RNA_PluginTexture;
 +              case TEX_ENVMAP:
 +                      return &RNA_EnvironmentMapTexture;
 +              case TEX_MUSGRAVE:
 +                      return &RNA_MusgraveTexture;
 +              case TEX_VORONOI:
 +                      return &RNA_VoronoiTexture;
 +              case TEX_DISTNOISE:
 +                      return &RNA_DistortedNoiseTexture;
++              case TEX_POINTDENSITY:
++                      return &RNA_PointDensityTexture;
++              case TEX_VOXELDATA:
++                      return &RNA_VoxelDataTexture;
 +              default:
 +                      return &RNA_Texture;
 +      }
 +}
 +
++static void rna_Texture_type_set(PointerRNA *ptr, int value)
++{
++      Tex *tex= (Tex*)ptr->data;
++
++      if (value == TEX_VOXELDATA) {
++              if (tex->vd == NULL) {
++                      tex->vd = BKE_add_voxeldata();
++              }
++      } else if (value == TEX_POINTDENSITY) {
++              if (tex->pd == NULL) {
++                      tex->pd = BKE_add_pointdensity();
++              }
++      }
++      
++      tex->type = value;
++}
++
 +static int rna_TextureSlot_name_length(PointerRNA *ptr)
 +{
 +      MTex *mtex= ptr->data;
 +
 +      if(mtex->tex)
 +              return strlen(mtex->tex->id.name+2);
 +      
 +      return 0;
 +}
 +
 +static void rna_TextureSlot_name_get(PointerRNA *ptr, char *str)
 +{
 +      MTex *mtex= ptr->data;
 +
 +      if(mtex->tex)
 +              strcpy(str, mtex->tex->id.name+2);
 +      else
 +              strcpy(str, "");
 +}
 +
 +static void rna_Texture_use_color_ramp_set(PointerRNA *ptr, int value)
 +{
 +      Tex *tex= (Tex*)ptr->data;
 +
 +      if(value) tex->flag |= TEX_COLORBAND;
 +      else tex->flag &= ~TEX_COLORBAND;
 +
 +      if((tex->flag & TEX_COLORBAND) && tex->coba == NULL)
 +              tex->coba= add_colorband(0);
 +}
 +
 +static void rna_ImageTexture_mipmap_set(PointerRNA *ptr, int value)
 +{
 +      Tex *tex= (Tex*)ptr->data;
 +
 +      if(value) tex->imaflag |= TEX_MIPMAP;
 +      else tex->imaflag &= ~TEX_MIPMAP;
 +
 +      if((tex->imaflag & TEX_MIPMAP) && tex->texfilter == TXF_SAT)
 +              tex->texfilter = TXF_EWA;
 +}
 +
 +static EnumPropertyItem *rna_ImageTexture_filter_itemf(bContext *C, PointerRNA *ptr, int *free)
 +{
 +      Tex *tex= (Tex*)ptr->data;
 +      EnumPropertyItem *item= NULL;
 +      int totitem= 0;
 +
 +      RNA_enum_items_add_value(&item, &totitem, texture_filter_items, TXF_BOX);
 +      RNA_enum_items_add_value(&item, &totitem, texture_filter_items, TXF_EWA);
 +      RNA_enum_items_add_value(&item, &totitem, texture_filter_items, TXF_FELINE);
 +      RNA_enum_items_add_value(&item, &totitem, texture_filter_items, TXF_AREA);
 +      if(tex->imaflag & TEX_MIPMAP)
 +              RNA_enum_items_add_value(&item, &totitem, texture_filter_items, TXF_SAT);
 +      
 +      *free= 1;
 +
 +      return item;
 +}
 +
 +#else
 +
 +static void rna_def_color_ramp_element(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      srna= RNA_def_struct(brna, "ColorRampElement", NULL);
 +      RNA_def_struct_sdna(srna, "CBData");
 +      RNA_def_struct_ui_text(srna, "Color Ramp Element", "Element defining a color at a position in the color ramp.");
 +
 +      prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
 +      RNA_def_property_float_sdna(prop, NULL, "r");
 +      RNA_def_property_array(prop, 4);
 +      RNA_def_property_ui_text(prop, "Color", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "position", PROP_FLOAT, PROP_COLOR);
 +      RNA_def_property_float_sdna(prop, NULL, "pos");
 +      RNA_def_property_range(prop, 0, 1);
 +      RNA_def_property_ui_text(prop, "Position", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_color_ramp(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_interpolation_items[] = {
 +              {1, "EASE", 0, "Ease", ""},
 +              {3, "CARDINAL", 0, "Cardinal", ""},
 +              {0, "LINEAR", 0, "Linear", ""},
 +              {2, "B_SPLINE", 0, "B-Spline", ""},
 +              {4, "CONSTANT", 0, "Constant", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "ColorRamp", NULL);
 +      RNA_def_struct_sdna(srna, "ColorBand");
 +      RNA_def_struct_ui_text(srna, "Color Ramp", "Color ramp mapping a scalar value to a color.");
 +
 +      prop= RNA_def_property(srna, "elements", PROP_COLLECTION, PROP_COLOR);
 +      RNA_def_property_collection_sdna(prop, NULL, "data", "tot");
 +      RNA_def_property_struct_type(prop, "ColorRampElement");
 +      RNA_def_property_ui_text(prop, "Elements", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "ipotype");
 +      RNA_def_property_enum_items(prop, prop_interpolation_items);
 +      RNA_def_property_ui_text(prop, "Interpolation", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_texmapping(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +      
 +      srna= RNA_def_struct(brna, "TexMapping", NULL);
 +      RNA_def_struct_ui_text(srna, "Texture Mapping", "Mapping settings");
 +
 +      prop= RNA_def_property(srna, "location", PROP_FLOAT, PROP_TRANSLATION);
 +      RNA_def_property_float_sdna(prop, NULL, "loc");
 +      RNA_def_property_ui_text(prop, "Location", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_EULER);
 +      RNA_def_property_float_sdna(prop, NULL, "rot");
 +      RNA_def_property_ui_text(prop, "Rotation", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
 +      RNA_def_property_float_sdna(prop, NULL, "size");
 +      RNA_def_property_ui_text(prop, "Scale", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "minimum", PROP_FLOAT, PROP_XYZ);
 +      RNA_def_property_float_sdna(prop, NULL, "min");
 +      RNA_def_property_ui_text(prop, "Minimum", "Minimum value for clipping");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "maximum", PROP_FLOAT, PROP_XYZ);
 +      RNA_def_property_float_sdna(prop, NULL, "max");
 +      RNA_def_property_ui_text(prop, "Maximum", "Maximum value for clipping");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "has_minimum", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MIN);
 +      RNA_def_property_ui_text(prop, "Has Minimum", "Whether to use minimum clipping value");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "has_maximum", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MAX);
 +      RNA_def_property_ui_text(prop, "Has Maximum", "Whether to use maximum clipping value");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_mtex(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_blend_type_items[] = {
 +              {MTEX_BLEND, "MIX", 0, "Mix", ""},
 +              {MTEX_ADD, "ADD", 0, "Add", ""},
 +              {MTEX_SUB, "SUBTRACT", 0, "Subtract", ""},
 +              {MTEX_MUL, "MULTIPLY", 0, "Multiply", ""},
 +              {MTEX_SCREEN, "SCREEN", 0, "Screen", ""},
 +              {MTEX_OVERLAY, "OVERLAY", 0, "Overlay", ""},
 +              {MTEX_DIFF, "DIFFERENCE", 0, "Difference", ""},
 +              {MTEX_DIV, "DIVIDE", 0, "Divide", ""},
 +              {MTEX_DARK, "DARKEN", 0, "Darken", ""},
 +              {MTEX_LIGHT, "LIGHTEN", 0, "Lighten", ""},
 +              {MTEX_BLEND_HUE, "HUE", 0, "Hue", ""},
 +              {MTEX_BLEND_SAT, "SATURATION", 0, "Saturation", ""},
 +              {MTEX_BLEND_VAL, "VALUE", 0, "Value", ""},
 +              {MTEX_BLEND_COLOR, "COLOR", 0, "Color", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "TextureSlot", NULL);
 +      RNA_def_struct_sdna(srna, "MTex");
 +      RNA_def_struct_ui_text(srna, "Texture Slot", "Texture slot defining the mapping and influence of a texture.");
 +      RNA_def_struct_ui_icon(srna, ICON_TEXTURE_DATA);
 +
 +      prop= RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "tex");
 +      RNA_def_property_struct_type(prop, "Texture");
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Texture", "Texture datablock used by this texture slot.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 +      RNA_def_property_string_funcs(prop, "rna_TextureSlot_name_get", "rna_TextureSlot_name_length", NULL);
 +      RNA_def_property_ui_text(prop, "Name", "Texture slot name.");
 +      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      RNA_def_struct_name_property(srna, prop);
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      /* mapping */
 +      prop= RNA_def_property(srna, "offset", PROP_FLOAT, PROP_TRANSLATION);
 +      RNA_def_property_float_sdna(prop, NULL, "ofs");
 +      RNA_def_property_ui_range(prop, -10, 10, 10, 2);
 +      RNA_def_property_ui_text(prop, "Offset", "Fine tunes texture mapping X, Y and Z locations.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "size", PROP_FLOAT, PROP_XYZ);
 +      RNA_def_property_ui_range(prop, -100, 100, 10, 2);
 +      RNA_def_property_ui_text(prop, "Size", "Sets scaling for the texture's X, Y and Z sizes.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
 +      RNA_def_property_float_sdna(prop, NULL, "r");
 +      RNA_def_property_array(prop, 3);
 +      RNA_def_property_ui_text(prop, "Color", "The default color for textures that don't return RGB.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "blendtype");
 +      RNA_def_property_enum_items(prop, prop_blend_type_items);
 +      RNA_def_property_ui_text(prop, "Blend Type", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "stencil", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "texflag", MTEX_STENCIL);
 +      RNA_def_property_ui_text(prop, "Stencil", "Use this texture as a blending value on the next texture.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "negate", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "texflag", MTEX_NEGATIVE);
 +      RNA_def_property_ui_text(prop, "Negate", "Inverts the values of the texture to reverse its effect.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "rgb_to_intensity", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "texflag", MTEX_RGBTOINT);
 +      RNA_def_property_ui_text(prop, "RGB to Intensity", "Converts texture RGB values to intensity (gray) values.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "def_var");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Default Value", "Value to use for Ref, Spec, Amb, Emit, Alpha, RayMir, TransLu and Hard.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "variable_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "varfac");
 +      RNA_def_property_ui_range(prop, 0, 1, 10, 3);
 +      RNA_def_property_ui_text(prop, "Variable Factor", "Amount texture affects other values.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "normal_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "norfac");
 +      RNA_def_property_ui_range(prop, 0, 5, 10, 3);
 +      RNA_def_property_ui_text(prop, "Normal Factor", "Amount texture affects normal values.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_filter_size_common(StructRNA *srna) 
 +{
 +      PropertyRNA *prop;
 +
 +      /* XXX: not sure about the name of this, "Min" seems a bit off */
 +      prop= RNA_def_property(srna, "use_filter", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "imaflag", TEX_FILTER_MIN);
 +      RNA_def_property_ui_text(prop, "Use Filter", "Use Filter Size as a minimal filter value in pixels");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "filter_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "filtersize");
 +      RNA_def_property_range(prop, 0.1, 50.0);
 +      RNA_def_property_ui_range(prop, 0.1, 50.0, 1, 0.2);
 +      RNA_def_property_ui_text(prop, "Filter Size", "Multiplies the filter size used by MIP Map and Interpolation");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_environment_map_common(StructRNA *srna)
 +{
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_source_items[] = {
 +              {ENV_STATIC, "STATIC", 0, "Static", "Calculates environment map only once"},
 +              {ENV_ANIM, "ANIMATED", 0, "Animated", "Calculates environment map at each rendering"},
 +              {ENV_LOAD, "LOADED", 0, "Loaded", "Loads saved environment map from disk"},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      prop= RNA_def_property(srna, "source", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "stype");
 +      RNA_def_property_enum_items(prop, prop_source_items);
 +      RNA_def_property_ui_text(prop, "Source", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      /* XXX: move this to specific types if needed */
 +      prop= RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "ima");
 +      RNA_def_property_struct_type(prop, "Image");
 +      RNA_def_property_ui_text(prop, "Image", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_environment_map(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_type_items[] = {
 +              {ENV_CUBE, "CUBE", 0, "Cube", "Use environment map with six cube sides."},
 +              {ENV_PLANE, "PLANE", 0, "Plane", "Only one side is rendered, with Z axis pointing in direction of image."},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "EnvironmentMap", NULL);
 +      RNA_def_struct_sdna(srna, "EnvMap");
 +      RNA_def_struct_ui_text(srna, "EnvironmentMap", "Environment map created by the renderer and cached for subsequent renders.");
 +
 +      rna_def_environment_map_common(srna);
 +
 +      prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "type");
 +      RNA_def_property_enum_items(prop, prop_type_items);
 +      RNA_def_property_ui_text(prop, "Type", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "clip_start", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "clipsta");
 +      RNA_def_property_range(prop, 0.01, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.01, 50, 100, 2);
 +      RNA_def_property_ui_text(prop, "Clip Start", "Objects nearer than this are not visible to map.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "clip_end", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "clipend");
 +      RNA_def_property_range(prop, 0.01, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.10, 20000, 100, 2);
 +      RNA_def_property_ui_text(prop, "Clip End", "Objects further than this are not visible to map.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "zoom", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "viewscale");
 +      RNA_def_property_range(prop, 0.01, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.5, 5, 100, 2);
 +      RNA_def_property_ui_text(prop, "Zoom", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      /* XXX: EnvMap.notlay */
 +      
 +      prop= RNA_def_property(srna, "resolution", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "cuberes");
 +      RNA_def_property_range(prop, 50, 4096);
 +      RNA_def_property_ui_text(prop, "Resolution", "Pixel resolution of the rendered environment map.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "depth", PROP_INT, PROP_NONE);
 +      RNA_def_property_range(prop, 0, 5);
 +      RNA_def_property_ui_text(prop, "Depth", "Number of times a map will be rendered recursively (mirror effects.)");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static EnumPropertyItem prop_noise_basis_items[] = {
 +      {TEX_BLENDER, "BLENDER_ORIGINAL", 0, "Blender Original", ""},
 +      {TEX_STDPERLIN, "ORIGINAL_PERLIN", 0, "Original Perlin", ""},
 +      {TEX_NEWPERLIN, "IMPROVED_PERLIN", 0, "Improved Perlin", ""},
 +      {TEX_VORONOI_F1, "VORONOI_F1", 0, "Voronoi F1", ""},
 +      {TEX_VORONOI_F2, "VORONOI_F2", 0, "Voronoi F2", ""},
 +      {TEX_VORONOI_F3, "VORONOI_F3", 0, "Voronoi F3", ""},
 +      {TEX_VORONOI_F4, "VORONOI_F4", 0, "Voronoi F4", ""},
 +      {TEX_VORONOI_F2F1, "VORONOI_F2_F1", 0, "Voronoi F2-F1", ""},
 +      {TEX_VORONOI_CRACKLE, "VORONOI_CRACKLE", 0, "Voronoi Crackle", ""},
 +      {TEX_CELLNOISE, "CELL_NOISE", 0, "Cell Noise", ""},
 +      {0, NULL, 0, NULL, NULL}};
 +
 +static EnumPropertyItem prop_noise_type[] = {
 +      {TEX_NOISESOFT, "SOFT_NOISE", 0, "Soft", ""},
 +      {TEX_NOISEPERL, "HARD_NOISE", 0, "Hard", ""},
 +      {0, NULL, 0, NULL, NULL}};
 +
 +
 +static void rna_def_texture_clouds(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_clouds_stype[] = {
 +      {TEX_DEFAULT, "GREYSCALE", 0, "Greyscale", ""},
 +      {TEX_COLOR, "COLOR", 0, "Color", ""},
 +      {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "CloudsTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Clouds Texture", "Procedural noise texture.");
 +      RNA_def_struct_sdna(srna, "Tex");
 +
 +      prop= RNA_def_property(srna, "noise_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "noisesize");
 +      RNA_def_property_range(prop, 0.0001, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.0001, 2, 10, 2);
 +      RNA_def_property_ui_text(prop, "Noise Size", "Sets scaling for noise input");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_depth", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "noisedepth");
 +      RNA_def_property_range(prop, 0, INT_MAX);
 +      RNA_def_property_ui_range(prop, 0, 6, 0, 2);
 +      RNA_def_property_ui_text(prop, "Noise Depth", "Sets the depth of the cloud calculation");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_basis", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "noisebasis");
 +      RNA_def_property_enum_items(prop, prop_noise_basis_items);
 +      RNA_def_property_ui_text(prop, "Noise Basis", "Sets the noise basis used for turbulence");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "noisetype");
 +      RNA_def_property_enum_items(prop, prop_noise_type);
 +      RNA_def_property_ui_text(prop, "Noise Type", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "stype", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "stype");
 +      RNA_def_property_enum_items(prop, prop_clouds_stype);
 +      RNA_def_property_ui_text(prop, "Color", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "nabla", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.001, 0.1);
 +      RNA_def_property_ui_range(prop, 0.001, 0.1, 1, 2);
 +      RNA_def_property_ui_text(prop, "Nabla", "Size of derivative offset used for calculating normal");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_texture_wood(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_wood_stype[] = {
 +      {TEX_BAND, "BANDS", 0, "Bands", "Uses standard wood texture in bands"},
 +      {TEX_RING, "RINGS", 0, "Rings", "Uses wood texture in rings"},
 +      {TEX_BANDNOISE, "BANDNOISE", 0, "Band Noise", "Adds noise to standard wood"},
 +      {TEX_RINGNOISE, "RINGNOISE", 0, "Ring Noise", "Adds noise to rings"},
 +      {0, NULL, 0, NULL, NULL}};
 +
 +      static EnumPropertyItem prop_wood_noisebasis2[] = {
 +      {TEX_SIN, "SIN", 0, "Sine", "Uses a sine wave to produce bands"},
 +      {TEX_SAW, "SAW", 0, "Saw", "Uses a saw wave to produce bands"},
 +      {TEX_TRI, "TRI", 0, "Tri", "Uses a triangle wave to produce bands"},
 +      {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "WoodTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Wood Texture", "Procedural noise texture.");
 +      RNA_def_struct_sdna(srna, "Tex");
 +
 +      prop= RNA_def_property(srna, "noise_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "noisesize");
 +      RNA_def_property_range(prop, 0.0001, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.0001, 2, 10, 2);
 +      RNA_def_property_ui_text(prop, "Noise Size", "Sets scaling for noise input");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "turbulence", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "turbul");
 +      RNA_def_property_range(prop, 0.0001, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.0001, 200, 10, 2);
 +      RNA_def_property_ui_text(prop, "Turbulence", "Sets the turbulence of the bandnoise and ringnoise types");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_basis", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "noisebasis");
 +      RNA_def_property_enum_items(prop, prop_noise_basis_items);
 +      RNA_def_property_ui_text(prop, "Noise Basis", "Sets the noise basis used for turbulence");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "noisetype");
 +      RNA_def_property_enum_items(prop, prop_noise_type);
 +      RNA_def_property_ui_text(prop, "Noise Type", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "stype", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "stype");
 +      RNA_def_property_enum_items(prop, prop_wood_stype);
 +      RNA_def_property_ui_text(prop, "Pattern", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noisebasis2", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "noisebasis2");
 +      RNA_def_property_enum_items(prop, prop_wood_noisebasis2);
 +      RNA_def_property_ui_text(prop, "Noise Basis 2", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "nabla", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.001, 0.1);
 +      RNA_def_property_ui_range(prop, 0.001, 0.1, 1, 2);
 +      RNA_def_property_ui_text(prop, "Nabla", "Size of derivative offset used for calculating normal.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +}
 +
 +static void rna_def_texture_marble(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_marble_stype[] = {
 +      {TEX_SOFT, "SOFT", 0, "Soft", "Uses soft marble"},
 +      {TEX_SHARP, "SHARP", 0, "Sharp", "Uses more clearly defined marble"},
 +      {TEX_SHARPER, "SHARPER", 0, "Sharper", "Uses very clearly defined marble"},
 +      {0, NULL, 0, NULL, NULL}};
 +
 +      static EnumPropertyItem prop_marble_noisebasis2[] = {
 +      {TEX_SIN, "SIN", 0, "Sin", "Uses a sine wave to produce bands"},
 +      {TEX_SAW, "SAW", 0, "Saw", "Uses a saw wave to produce bands"},
 +      {TEX_TRI, "TRI", 0, "Tri", "Uses a triangle wave to produce bands"},
 +      {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "MarbleTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Marble Texture", "Procedural noise texture.");
 +      RNA_def_struct_sdna(srna, "Tex");
 +
 +      prop= RNA_def_property(srna, "noise_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "noisesize");
 +      RNA_def_property_range(prop, 0.0001, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.0001, 2, 10, 2);
 +      RNA_def_property_ui_text(prop, "Noise Size", "Sets scaling for noise input");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "turbulence", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "turbul");
 +      RNA_def_property_range(prop, 0.0001, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.0001, 200, 10, 2);
 +      RNA_def_property_ui_text(prop, "Turbulence", "Sets the turbulence of the bandnoise and ringnoise types");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_depth", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "noisedepth");
 +      RNA_def_property_range(prop, 0, INT_MAX);
 +      RNA_def_property_ui_range(prop, 0, 6, 0, 2);
 +      RNA_def_property_ui_text(prop, "Noise Depth", "Sets the depth of the cloud calculation");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "noisetype");
 +      RNA_def_property_enum_items(prop, prop_noise_type);
 +      RNA_def_property_ui_text(prop, "Noise Type", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "stype", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "stype");
 +      RNA_def_property_enum_items(prop, prop_marble_stype);
 +      RNA_def_property_ui_text(prop, "Pattern", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "noise_basis", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "noisebasis");
 +      RNA_def_property_enum_items(prop, prop_noise_basis_items);
 +      RNA_def_property_ui_text(prop, "Noise Basis", "Sets the noise basis used for turbulence");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noisebasis2", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "noisebasis2");
 +      RNA_def_property_enum_items(prop, prop_marble_noisebasis2);
 +      RNA_def_property_ui_text(prop, "Noise Basis 2", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "nabla", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.001, 0.1);
 +      RNA_def_property_ui_range(prop, 0.001, 0.1, 1, 2);
 +      RNA_def_property_ui_text(prop, "Nabla", "Size of derivative offset used for calculating normal.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +}
 +
 +static void rna_def_texture_magic(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      srna= RNA_def_struct(brna, "MagicTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Magic Texture", "Procedural noise texture.");
 +      RNA_def_struct_sdna(srna, "Tex");
 +
 +      prop= RNA_def_property(srna, "turbulence", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "turbul");
 +      RNA_def_property_range(prop, 0.0001, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.0001, 200, 10, 2);
 +      RNA_def_property_ui_text(prop, "Turbulence", "Sets the turbulence of the bandnoise and ringnoise types");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_depth", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "noisedepth");
 +      RNA_def_property_range(prop, 0, INT_MAX);
 +      RNA_def_property_ui_range(prop, 0, 6, 0, 2);
 +      RNA_def_property_ui_text(prop, "Noise Depth", "Sets the depth of the cloud calculation");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_texture_blend(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_blend_progression[] = {
 +              {TEX_LIN, "LINEAR", 0, "Linear", "Creates a linear progression"},
 +              {TEX_QUAD, "QUADRATIC", 0, "Quadratic", "Creates a quadratic progression"},
 +              {TEX_EASE, "EASING", 0, "Easing", "Creates a progression easing from one step to the next"},
 +              {TEX_DIAG, "DIAGONAL", 0, "Diagonal", "Creates a diagonal progression"},
 +              {TEX_SPHERE, "SPHERICAL", 0, "Spherical", "Creates a spherical progression"},
 +              {TEX_HALO, "QUADRATIC_SPHERE", 0, "Quadratic sphere", "Creates a quadratic progression in the shape of a sphere"},
 +              {TEX_RAD, "RADIAL", 0, "Radial", "Creates a radial progression"},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "BlendTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Blend Texture", "Procedural color blending texture.");
 +      RNA_def_struct_sdna(srna, "Tex");
 +
 +      prop= RNA_def_property(srna, "progression", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "stype");
 +      RNA_def_property_enum_items(prop, prop_blend_progression);
 +      RNA_def_property_ui_text(prop, "Progression", "Sets the style of the color blending");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "flip_axis", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", TEX_FLIPBLEND);
 +      RNA_def_property_ui_text(prop, "Flip Axis", "Flips the texture's X and Y axis");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_texture_stucci(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_stucci_stype[] = {
 +      {TEX_PLASTIC, "PLASTIC", 0, "Plastic", "Uses standard stucci"},
 +      {TEX_WALLIN, "WALL_IN", 0, "Wall in", "Creates Dimples"},
 +      {TEX_WALLOUT, "WALL_OUT", 0, "Wall out", "Creates Ridges"},
 +      {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "StucciTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Stucci Texture", "Procedural noise texture.");
 +      RNA_def_struct_sdna(srna, "Tex");
 +
 +      prop= RNA_def_property(srna, "turbulence", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "turbul");
 +      RNA_def_property_range(prop, 0.0001, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.0001, 200, 10, 2);
 +      RNA_def_property_ui_text(prop, "Turbulence", "Sets the turbulence of the bandnoise and ringnoise types");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +      
 +      prop= RNA_def_property(srna, "noise_basis", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "noisebasis");
 +      RNA_def_property_enum_items(prop, prop_noise_basis_items);
 +      RNA_def_property_ui_text(prop, "Noise Basis", "Sets the noise basis used for turbulence");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "noisesize");
 +      RNA_def_property_range(prop, 0.0001, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.0001, 2, 10, 2);
 +      RNA_def_property_ui_text(prop, "Noise Size", "Sets scaling for noise input");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "noisetype");
 +      RNA_def_property_enum_items(prop, prop_noise_type);
 +      RNA_def_property_ui_text(prop, "Noise Type", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "stype", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "stype");
 +      RNA_def_property_enum_items(prop, prop_stucci_stype);
 +      RNA_def_property_ui_text(prop, "Pattern", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_texture_noise(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +
 +      srna= RNA_def_struct(brna, "NoiseTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Noise Texture", "Procedural noise texture.");
 +      RNA_def_struct_sdna(srna, "Tex");
 +}
 +
 +static void rna_def_texture_image(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_image_extension[] = {
 +              {1, "EXTEND", 0, "Extend", "Extends by repeating edge pixels of the image"},
 +              {2, "CLIP", 0, "Clip", "Clips to image size and sets exterior pixels as transparent"},
 +              {4, "CLIP_CUBE", 0, "Clip Cube", "Clips to cubic-shaped area around the image and sets exterior pixels as transparent"},
 +              {3, "REPEAT", 0, "Repeat", "Causes the image to repeat horizontally and vertically"},
 +              {5, "CHECKER", 0, "Checker", "Causes the image to repeat in checker board pattern"},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "ImageTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Image Texture", "");
 +      RNA_def_struct_sdna(srna, "Tex");
 +
 +      prop= RNA_def_property(srna, "mipmap", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "imaflag", TEX_MIPMAP);
 +      RNA_def_property_boolean_funcs(prop, NULL, "rna_ImageTexture_mipmap_set");
 +      RNA_def_property_ui_text(prop, "MIP Map", "Uses auto-generated MIP maps for the image");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "mipmap_gauss", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "imaflag", TEX_GAUSS_MIP);
 +      RNA_def_property_ui_text(prop, "MIP Map Gauss", "Uses Gauss filter to sample down MIP maps");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "interpolation", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "imaflag", TEX_INTERPOL);
 +      RNA_def_property_ui_text(prop, "Interpolation", "Interpolates pixels using Area filter");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      /* XXX: I think flip_axis should be a generic Texture property, enabled for all the texture types */
 +      prop= RNA_def_property(srna, "flip_axis", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "imaflag", TEX_IMAROT);
 +      RNA_def_property_ui_text(prop, "Flip Axis", "Flips the texture's X and Y axis");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "imaflag", TEX_USEALPHA);
 +      RNA_def_property_ui_text(prop, "Use Alpha", "Uses the alpha channel information in the image");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "calculate_alpha", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "imaflag", TEX_CALCALPHA);
 +      RNA_def_property_ui_text(prop, "Calculate Alpha", "Calculates an alpha channel based on RGB values in the image");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "invert_alpha", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", TEX_NEGALPHA);
 +      RNA_def_property_ui_text(prop, "Invert Alpha", "Inverts all the alpha values in the image");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      rna_def_filter_size_common(srna);
 +
 +      prop= RNA_def_property(srna, "normal_map", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "imaflag", TEX_NORMALMAP);
 +      RNA_def_property_ui_text(prop, "Normal Map", "Uses image RGB values for normal mapping");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      /* XXX: mtex->normapspace "Sets space of normal map image" "Normal Space %t|Camera %x0|World %x1|Object %x2|Tangent %x3" 
 +       *                      not sure why this goes in mtex instead of texture directly? */
 +
 +      prop= RNA_def_property(srna, "extension", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "extend");
 +      RNA_def_property_enum_items(prop, prop_image_extension);
 +      RNA_def_property_ui_text(prop, "Extension", "Sets how the image is stretched in the texture");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "repeat_x", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "xrepeat");
 +      RNA_def_property_range(prop, 1, 512);
 +      RNA_def_property_ui_text(prop, "Repeat X", "Sets a repetition multiplier in the X direction");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "repeat_y", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "yrepeat");
 +      RNA_def_property_range(prop, 1, 512);
 +      RNA_def_property_ui_text(prop, "Repeat Y", "Sets a repetition multiplier in the Y direction");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "mirror_x", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", TEX_REPEAT_XMIR);
 +      RNA_def_property_ui_text(prop, "Mirror X", "Mirrors the image repetition on the X direction");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "mirror_y", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", TEX_REPEAT_YMIR);
 +      RNA_def_property_ui_text(prop, "Mirror Y", "Mirrors the image repetition on the Y direction");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "checker_odd", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", TEX_CHECKER_ODD);
 +      RNA_def_property_ui_text(prop, "Checker Odd", "Sets odd checker tiles");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "checker_even", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", TEX_CHECKER_EVEN);
 +      RNA_def_property_ui_text(prop, "Checker Even", "Sets even checker tiles");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "checker_distance", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "checkerdist");
 +      RNA_def_property_range(prop, 0.0, 0.99);
 +      RNA_def_property_ui_range(prop, 0.0, 0.99, 0.1, 0.01);
 +      RNA_def_property_ui_text(prop, "Checker Distance", "Sets distance between checker tiles");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +#if 0
 +
 +      /* XXX: did this as an array, but needs better descriptions than "1 2 3 4"
 +      perhaps a new subtype could be added? 
 +      --I actually used single values for this, maybe change later with a RNA_Rect thing? */
 +      prop= RNA_def_property(srna, "crop_rectangle", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "cropxmin");
 +      RNA_def_property_array(prop, 4);
 +      RNA_def_property_range(prop, -10, 10);
 +      RNA_def_property_ui_text(prop, "Crop Rectangle", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +#endif
 +
 +      prop= RNA_def_property(srna, "crop_min_x", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "cropxmin");
 +      RNA_def_property_range(prop, -10.0, 10.0);
 +      RNA_def_property_ui_range(prop, -10.0, 10.0, 1, 0.2);
 +      RNA_def_property_ui_text(prop, "Crop Minimum X", "Sets minimum X value to crop the image");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "crop_min_y", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "cropymin");
 +      RNA_def_property_range(prop, -10.0, 10.0);
 +      RNA_def_property_ui_range(prop, -10.0, 10.0, 1, 0.2);
 +      RNA_def_property_ui_text(prop, "Crop Minimum Y", "Sets minimum Y value to crop the image");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "crop_max_x", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "cropxmax");
 +      RNA_def_property_range(prop, -10.0, 10.0);
 +      RNA_def_property_ui_range(prop, -10.0, 10.0, 1, 0.2);
 +      RNA_def_property_ui_text(prop, "Crop Maximum X", "Sets maximum X value to crop the image");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "crop_max_y", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "cropymax");
 +      RNA_def_property_range(prop, -10.0, 10.0);
 +      RNA_def_property_ui_range(prop, -10.0, 10.0, 1, 0.2);
 +      RNA_def_property_ui_text(prop, "Crop Maximum Y", "Sets maximum Y value to crop the image");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "ima");
 +      RNA_def_property_struct_type(prop, "Image");
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Image", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      /* filtering */
 +      prop= RNA_def_property(srna, "filter", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "texfilter");
 +      RNA_def_property_enum_items(prop, texture_filter_items);
 +      RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_ImageTexture_filter_itemf");
 +      RNA_def_property_ui_text(prop, "Filter", "Texture filter to use for sampling image.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "filter_probes", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "afmax");
 +      RNA_def_property_range(prop, 1, 256);
 +      RNA_def_property_ui_text(prop, "Filter Probes", "Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "filter_eccentricity", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "afmax");
 +      RNA_def_property_range(prop, 1, 256);
 +      RNA_def_property_ui_text(prop, "Filter Eccentricity", "Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower.");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_texture_plugin(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +
 +      srna= RNA_def_struct(brna, "PluginTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Plugin", "External plugin texture.");
 +      RNA_def_struct_sdna(srna, "Tex");
 +
 +      /* XXX: todo */
 +}
 +
 +static void rna_def_texture_environment_map(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      srna= RNA_def_struct(brna, "EnvironmentMapTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Environment Map", "Environment map texture.");
 +      RNA_def_struct_sdna(srna, "Tex");
 +
 +      rna_def_environment_map_common(srna);
 +
 +      prop= RNA_def_property(srna, "environment_map", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "env");
 +      RNA_def_property_struct_type(prop, "EnvironmentMap");
 +      RNA_def_property_ui_text(prop, "Environment Map", "Gets the environment map associated with this texture");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      rna_def_filter_size_common(srna);
 +}
 +
 +static void rna_def_texture_musgrave(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_musgrave_type[] = {
 +              {TEX_MFRACTAL, "MULTIFRACTAL", 0, "Multifractal", ""},
 +              {TEX_RIDGEDMF, "RIDGED_MULTIFRACTAL", 0, "Ridged Multifractal", ""},
 +              {TEX_HYBRIDMF, "HYBRID_MULTIFRACTAL", 0, "Hybrid Multifractal", ""},
 +              {TEX_FBM, "FBM", 0, "fBM", ""},
 +              {TEX_HTERRAIN, "HETERO_TERRAIN", 0, "Hetero Terrain", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "MusgraveTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Musgrave", "Procedural musgrave texture.");
 +      RNA_def_struct_sdna(srna, "Tex");
 +
 +      prop= RNA_def_property(srna, "musgrave_type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "stype");
 +      RNA_def_property_enum_items(prop, prop_musgrave_type);
 +      RNA_def_property_ui_text(prop, "Type", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "highest_dimension", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "mg_H");
 +      RNA_def_property_range(prop, 0.0001, 2);
 +      RNA_def_property_ui_text(prop, "Highest Dimension", "Highest fractal dimension");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "lacunarity", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "mg_lacunarity");
 +      RNA_def_property_range(prop, 0, 6);
 +      RNA_def_property_ui_text(prop, "Lacunarity", "Gap between succesive frequencies");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "octaves", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "mg_octaves");
 +      RNA_def_property_range(prop, 0, 8);
 +      RNA_def_property_ui_text(prop, "Octaves", "Number of frequencies used");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "mg_offset");
 +      RNA_def_property_range(prop, 0, 6);
 +      RNA_def_property_ui_text(prop, "Offset", "The fractal offset");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "gain", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "mg_gain");
 +      RNA_def_property_range(prop, 0, 6);
 +      RNA_def_property_ui_text(prop, "Gain", "The gain multiplier");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_intensity", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "ns_outscale");
 +      RNA_def_property_range(prop, 0, 10);
 +      RNA_def_property_ui_text(prop, "Noise Intensity", "");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "noisesize");
 +      RNA_def_property_range(prop, 0.0001, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.0001, 2, 10, 2);
 +      RNA_def_property_ui_text(prop, "Noise Size", "Sets scaling for noise input");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "noise_basis", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "noisebasis");
 +      RNA_def_property_enum_items(prop, prop_noise_basis_items);
 +      RNA_def_property_ui_text(prop, "Noise Basis", "Sets the noise basis used for turbulence");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +
 +      prop= RNA_def_property(srna, "nabla", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.001, 0.1);
 +      RNA_def_property_ui_range(prop, 0.001, 0.1, 1, 2);
 +      RNA_def_property_ui_text(prop, "Nabla", "Size of derivative offset used for calculating normal");
 +      RNA_def_property_update(prop, NC_TEXTURE, NULL);
 +}
 +
 +static void rna_def_texture_voronoi(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem prop_distance_metric_items[] = {
 +              {TEX_DISTANCE, "DISTANCE", 0, "Actual Distance", ""},
 +              {TEX_DISTANCE_SQUARED, "DISTANCE_SQUARED", 0, "Distance Squared", ""},
 +              {TEX_MANHATTAN, "MANHATTAN", 0, "Manhattan", ""},
 +              {TEX_CHEBYCHEV, "CHEBYCHEV", 0, "Chebychev", ""},
 +              {TEX_MINKOVSKY_HALF, "MINKOVSKY_HALF", 0, "Minkovsky 1/2", ""},
 +              {TEX_MINKOVSKY_FOUR, "MINKOVSKY_FOUR", 0, "Minkovsky 4", ""},
 +              {TEX_MINKOVSKY, "MINKOVSKY", 0, "Minkovsky", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      static EnumPropertyItem prop_coloring_items[] = {
 +              /* XXX: OK names / descriptions? */
 +              {TEX_INTENSITY, "INTENSITY", 0, "Intensity", "Only calculate intensity."},
 +              {TEX_COL1, "POSITION", 0, "Position", "Color cells by position."},
 +              {TEX_COL2, "POSITION_OUTLINE", 0, "Position and Outline", "Use position plus an outline based on F2-F.1"},
 +              {TEX_COL3, "POSITION_OUTLINE_INTENSITY", 0, "Position, Outline, and Intensity", "Multiply position and outline by intensity."},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      srna= RNA_def_struct(brna, "VoronoiTexture", "Texture");
 +      RNA_def_struct_ui_text(srna, "Voronoi", "Procedural voronoi texture.");
 +      RNA_def_struct_sdna(srna, "Tex");
 +
 +      prop= RNA_def_property(srna, "weight_1", PROP_FLOAT, PROP_NONE);
 +     &