forked from bartvdbraak/blender
Merging r38036 through r38196 from trunk into soc-2011-tomato
This commit is contained in:
commit
ef5110a033
@ -566,12 +566,15 @@ def AppIt(target=None, source=None, env=None):
|
||||
commands.getoutput(cmd)
|
||||
cmd = 'unzip -q %s/release/%s -d %s/%s.app/Contents/MacOS/%s/python/'%(libdir,python_zip,installdir,binary,VERSION)
|
||||
commands.getoutput(cmd)
|
||||
|
||||
if binary == 'blender':#not copy everything for blenderplayer
|
||||
cmd = 'cp -R %s/release/scripts %s/%s.app/Contents/MacOS/%s/'%(bldroot,installdir,binary,VERSION)
|
||||
commands.getoutput(cmd)
|
||||
cmd = 'cp -R %s/release/ui %s/%s.app/Contents/MacOS/%s/'%(bldroot,installdir,binary,VERSION)
|
||||
commands.getoutput(cmd)
|
||||
cmd = 'cp -R %s/release/io %s/%s.app/Contents/MacOS/%s/'%(bldroot,installdir,binary,VERSION)
|
||||
commands.getoutput(cmd)
|
||||
|
||||
cmd = 'chmod +x %s/%s.app/Contents/MacOS/%s'%(installdir,binary, binary)
|
||||
commands.getoutput(cmd)
|
||||
cmd = 'find %s/%s.app -name .svn -prune -exec rm -rf {} \;'%(installdir, binary)
|
||||
|
38
doc/python_api/examples/bge.texture.1.py
Normal file
38
doc/python_api/examples/bge.texture.1.py
Normal file
@ -0,0 +1,38 @@
|
||||
"""
|
||||
Texture replacement
|
||||
++++++++++++++++++++++
|
||||
Example of how to replace a texture in game with an external image.
|
||||
createTexture() and removeTexture() are to be called from a module Python
|
||||
Controller.
|
||||
"""
|
||||
import bge
|
||||
from bge import logic
|
||||
from bge import texture
|
||||
|
||||
def createTexture(cont):
|
||||
"""Create a new Dynamic Texture"""
|
||||
object = cont.owner
|
||||
|
||||
# get the reference pointer (ID) of the internal texture
|
||||
ID = VT.materialID(obj, 'IMoriginal.png')
|
||||
|
||||
# create a texture object
|
||||
object_texture = texture.Texture(object, ID)
|
||||
|
||||
# create a new source with an external image
|
||||
url = logic.expandPath("//newtexture.jpg")
|
||||
new_source = texture.ImageFFmpeg(url)
|
||||
|
||||
# the texture has to be stored in a permanent Python object
|
||||
logic.texture = object_texture
|
||||
|
||||
# update/replace the texture
|
||||
logic.texture.source = new_source
|
||||
logic.texture.refresh(False)
|
||||
|
||||
def removeTexture(cont):
|
||||
"""Delete the Dynamic Texture, reversing back the final to its original state."""
|
||||
try:
|
||||
del logic.texture
|
||||
except:
|
||||
pass
|
32
doc/python_api/examples/bge.texture.py
Normal file
32
doc/python_api/examples/bge.texture.py
Normal file
@ -0,0 +1,32 @@
|
||||
"""
|
||||
Basic Video Playback
|
||||
++++++++++++++++++++++
|
||||
Example of how to replace a texture in game with a video. It needs to run everyframe
|
||||
"""
|
||||
import bge
|
||||
from bge import texture
|
||||
from bge import logic
|
||||
|
||||
cont = logic.getCurrentController()
|
||||
obj = cont.owner
|
||||
|
||||
# the creation of the texture must be done once: save the
|
||||
# texture object in an attribute of bge.logic module makes it persistent
|
||||
if not hasattr(logic, 'video'):
|
||||
|
||||
# identify a static texture by name
|
||||
matID = texture.materialID(obj, 'IMvideo.png')
|
||||
|
||||
# create a dynamic texture that will replace the static texture
|
||||
logic.video = texture.Texture(obj, matID)
|
||||
|
||||
# define a source of image for the texture, here a movie
|
||||
movie = logic.expandPath('//trailer_400p.ogg')
|
||||
logic.video.source = texture.VideoFFmpeg(movie)
|
||||
logic.video.source.scale = True
|
||||
|
||||
# quick off the movie, but it wont play in the background
|
||||
logic.video.source.play()
|
||||
|
||||
# you need to call this function every frame to ensure update of the texture.
|
||||
logic.video.refresh(True)
|
42
doc/python_api/examples/blf.py
Normal file
42
doc/python_api/examples/blf.py
Normal file
@ -0,0 +1,42 @@
|
||||
"""
|
||||
Hello World Text Example
|
||||
++++++++++++++++++++++++
|
||||
Blender Game Engine example of using the blf module. For this module to work we
|
||||
need to use the OpenGL wrapper :class:`~bgl` as well.
|
||||
"""
|
||||
# import game engine modules
|
||||
import bge
|
||||
from bge import render
|
||||
from bge import logic
|
||||
# import stand alone modules
|
||||
import bgl
|
||||
import blf
|
||||
|
||||
def init():
|
||||
"""init function - runs once"""
|
||||
# create a new font object, use external ttf file
|
||||
font_path = logic.expandPath('//Zeyada.ttf')
|
||||
# store the font indice - to use later
|
||||
logic.font_id = blf.load(font_path)
|
||||
|
||||
# set the font drawing routine to run every frame
|
||||
scene = logic.getCurrentScene()
|
||||
scene.post_draw=[write]
|
||||
|
||||
def write():
|
||||
"""write on screen"""
|
||||
width = render.getWindowWidth()
|
||||
height = render.getWindowHeight()
|
||||
|
||||
# OpenGL setup
|
||||
bgl.glMatrixMode(bgl.GL_PROJECTION)
|
||||
bgl.glLoadIdentity()
|
||||
bgl.gluOrtho2D(0, width, 0, height)
|
||||
bgl.glMatrixMode(bgl.GL_MODELVIEW)
|
||||
bgl.glLoadIdentity()
|
||||
|
||||
# BLF drawing routine
|
||||
font_id = logic.font_id
|
||||
blf.position(font_id, (width*0.2), (height*0.3), 0)
|
||||
blf.size(font_id, 50, 72)
|
||||
blf.draw(font_id, "Hello World")
|
@ -17,7 +17,7 @@ Module to access logic functions, imported automatically into the python control
|
||||
# To get the game object this controller is on:
|
||||
obj = cont.owner
|
||||
|
||||
:class:`~bge.types.KX_GameObject` and :class:`~bge.types.KX_Camera` or :class:`bge.types.~KX_LightObject` methods are available depending on the type of object
|
||||
:class:`~bge.types.KX_GameObject` and :class:`~bge.types.KX_Camera` or :class:`~bge.types.KX_LightObject` methods are available depending on the type of object
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
|
451
doc/python_api/rst/bge.texture.rst
Normal file
451
doc/python_api/rst/bge.texture.rst
Normal file
@ -0,0 +1,451 @@
|
||||
|
||||
Game Engine bge.texture Module
|
||||
==============================
|
||||
|
||||
.. note::
|
||||
This documentation is still very weak, and needs some help! Right now they are mostly a collection
|
||||
of the docstrings found in the bge.texture source code + some random places filled with text.
|
||||
|
||||
*****
|
||||
Intro
|
||||
*****
|
||||
|
||||
The bge.texture module allows you to manipulate textures during the game.
|
||||
|
||||
Several sources for texture are possible: video files, image files, video capture, memory buffer, camera render or a mix of that.
|
||||
|
||||
The video and image files can be loaded from the internet using an URL instead of a file name.
|
||||
|
||||
In addition, you can apply filters on the images before sending them to the GPU, allowing video effect: blue screen, color band, gray, normal map.
|
||||
|
||||
bge.texture uses FFmpeg to load images and videos. All the formats and codecs that FFmpeg supports are supported by this module, including but not limited to::
|
||||
|
||||
* AVI
|
||||
* Ogg
|
||||
* Xvid
|
||||
* Theora
|
||||
* dv1394 camera
|
||||
* video4linux capture card (this includes many webcams)
|
||||
* videoForWindows capture card (this includes many webcams)
|
||||
* JPG
|
||||
|
||||
The principle is simple: first you identify a texture on an existing object using
|
||||
the :materialID: function, then you create a new texture with dynamic content
|
||||
and swap the two textures in the GPU.
|
||||
|
||||
The GE is not aware of the substitution and continues to display the object as always,
|
||||
except that you are now in control of the texture.
|
||||
|
||||
When the texture object is deleted, the new texture is deleted and the old texture restored.
|
||||
|
||||
.. module:: bge.texture
|
||||
|
||||
.. class:: VideoFFmpeg(file [, capture=-1, rate=25.0, width=0, height=0])
|
||||
|
||||
FFmpeg video source
|
||||
|
||||
.. attribute:: status
|
||||
video status
|
||||
|
||||
.. attribute:: range
|
||||
replay range
|
||||
|
||||
.. attribute:: repeat
|
||||
repeat count, -1 for infinite repeat
|
||||
|
||||
:type: int
|
||||
|
||||
.. attribute:: framerate
|
||||
frame rate
|
||||
|
||||
:type: float
|
||||
|
||||
.. attribute:: valid
|
||||
Tells if an image is available
|
||||
|
||||
:type: bool
|
||||
|
||||
.. attribute:: image
|
||||
image data
|
||||
|
||||
.. attribute:: size
|
||||
image size
|
||||
|
||||
.. attribute:: scale
|
||||
fast scale of image (near neighbour)
|
||||
|
||||
.. attribute:: flip
|
||||
flip image vertically
|
||||
|
||||
.. attribute:: filter
|
||||
pixel filter
|
||||
|
||||
.. attribute:: preseek
|
||||
number of frames of preseek
|
||||
|
||||
:type: int
|
||||
|
||||
.. attribute:: deinterlace
|
||||
deinterlace image
|
||||
|
||||
:type: bool
|
||||
|
||||
.. method:: play()
|
||||
Play (restart) video
|
||||
|
||||
.. method:: pause()
|
||||
pause video
|
||||
|
||||
.. method:: stop()
|
||||
stop video (play will replay it from start)
|
||||
|
||||
.. method:: refresh()
|
||||
Refresh video - get its status
|
||||
|
||||
.. class:: ImageFFmpeg(file)
|
||||
|
||||
FFmpeg image source
|
||||
|
||||
.. attribute:: status
|
||||
video status
|
||||
|
||||
.. attribute:: valid
|
||||
Tells if an image is available
|
||||
|
||||
:type: bool
|
||||
|
||||
.. attribute:: image
|
||||
image data
|
||||
|
||||
.. attribute:: size
|
||||
image size
|
||||
|
||||
.. attribute:: scale
|
||||
fast scale of image (near neighbour)
|
||||
|
||||
.. attribute:: flip
|
||||
flip image vertically
|
||||
|
||||
.. attribute:: filter
|
||||
pixel filter
|
||||
|
||||
.. method:: refresh()
|
||||
Refresh image, i.e. load it
|
||||
|
||||
.. method:: reload([newname])
|
||||
Reload image, i.e. reopen it
|
||||
|
||||
.. class:: ImageBuff()
|
||||
|
||||
Image source from image buffer
|
||||
|
||||
.. attribute:: filter
|
||||
pixel filter
|
||||
|
||||
.. attribute:: flip
|
||||
flip image vertically
|
||||
|
||||
.. attribute:: image
|
||||
image data
|
||||
|
||||
.. method:: load(imageBuffer, width, height)
|
||||
Load image from buffer
|
||||
|
||||
.. method:: plot(imageBuffer, width, height, positionX, positionY)
|
||||
update image buffer
|
||||
|
||||
.. attribute:: scale
|
||||
fast scale of image (near neighbour)
|
||||
|
||||
.. attribute:: size
|
||||
image size
|
||||
|
||||
.. attribute:: valid
|
||||
bool to tell if an image is available
|
||||
|
||||
.. class:: ImageMirror(scene)
|
||||
|
||||
Image source from mirror
|
||||
|
||||
.. attribute:: alpha
|
||||
use alpha in texture
|
||||
|
||||
.. attribute:: background
|
||||
background color
|
||||
|
||||
.. attribute:: capsize
|
||||
size of render area
|
||||
|
||||
.. attribute:: clip
|
||||
clipping distance
|
||||
|
||||
.. attribute:: filter
|
||||
pixel filter
|
||||
|
||||
.. attribute:: flip
|
||||
flip image vertically
|
||||
|
||||
.. attribute:: image
|
||||
image data
|
||||
|
||||
.. method:: refresh(imageMirror)
|
||||
Refresh image - invalidate its current content
|
||||
|
||||
.. attribute:: scale
|
||||
fast scale of image (near neighbour)
|
||||
|
||||
.. attribute:: size
|
||||
image size
|
||||
|
||||
.. attribute:: valid
|
||||
bool to tell if an image is available
|
||||
|
||||
.. attribute:: whole
|
||||
use whole viewport to render
|
||||
|
||||
.. class:: ImageMix()
|
||||
|
||||
Image mixer
|
||||
|
||||
.. attribute:: filter
|
||||
pixel filter
|
||||
|
||||
.. attribute:: flip
|
||||
flip image vertically
|
||||
|
||||
.. method:: getSource(imageMix)
|
||||
get image source
|
||||
|
||||
.. method:: getWeight(imageMix)
|
||||
get image source weight
|
||||
|
||||
.. attribute:: image
|
||||
image data
|
||||
|
||||
.. method:: refresh(imageMix)
|
||||
Refresh image - invalidate its current content
|
||||
|
||||
.. attribute:: scale
|
||||
fast scale of image (near neighbour)
|
||||
|
||||
.. method:: setSource(imageMix)
|
||||
set image source
|
||||
|
||||
.. method:: setWeight(imageMix)
|
||||
set image source weight
|
||||
|
||||
.. attribute:: valid
|
||||
bool to tell if an image is available
|
||||
|
||||
.. class:: ImageRender(scene, camera)
|
||||
|
||||
Image source from render
|
||||
|
||||
.. attribute:: alpha
|
||||
use alpha in texture
|
||||
|
||||
.. attribute:: background
|
||||
background color
|
||||
|
||||
.. attribute:: capsize
|
||||
size of render area
|
||||
|
||||
.. attribute:: filter
|
||||
pixel filter
|
||||
|
||||
.. attribute:: flip
|
||||
flip image vertically
|
||||
|
||||
.. attribute:: image
|
||||
image data
|
||||
|
||||
.. method:: refresh(imageRender)
|
||||
Refresh image - invalidate its current content
|
||||
|
||||
.. attribute:: scale
|
||||
fast scale of image (near neighbour)
|
||||
|
||||
.. attribute:: size
|
||||
image size
|
||||
|
||||
.. attribute:: valid
|
||||
bool to tell if an image is available
|
||||
|
||||
.. attribute:: whole
|
||||
use whole viewport to render
|
||||
|
||||
.. class:: ImageViewport()
|
||||
|
||||
Image source from viewport
|
||||
|
||||
.. attribute:: alpha
|
||||
use alpha in texture
|
||||
|
||||
.. attribute:: capsize
|
||||
size of viewport area being captured
|
||||
|
||||
.. attribute:: filter
|
||||
pixel filter
|
||||
|
||||
.. attribute:: flip
|
||||
flip image vertically
|
||||
|
||||
.. attribute:: image
|
||||
image data
|
||||
|
||||
.. attribute:: position
|
||||
upper left corner of captured area
|
||||
|
||||
.. method:: refresh(imageViewport)
|
||||
Refresh image - invalidate its current content
|
||||
|
||||
.. attribute:: scale
|
||||
fast scale of image (near neighbour)
|
||||
|
||||
.. attribute:: size
|
||||
image size
|
||||
|
||||
.. attribute:: valid
|
||||
bool to tell if an image is available
|
||||
|
||||
.. attribute:: whole
|
||||
use whole viewport to capture
|
||||
|
||||
.. class:: Texture(gameObj)
|
||||
|
||||
Texture objects
|
||||
|
||||
.. attribute:: bindId
|
||||
OpenGL Bind Name
|
||||
|
||||
.. method:: close(texture)
|
||||
Close dynamic texture and restore original
|
||||
|
||||
.. attribute:: mipmap
|
||||
mipmap texture
|
||||
|
||||
.. method:: refresh(texture)
|
||||
Refresh texture from source
|
||||
|
||||
.. attribute:: source
|
||||
source of texture
|
||||
|
||||
.. class:: FilterBGR24()
|
||||
|
||||
Source filter BGR24 objects
|
||||
|
||||
.. class:: FilterBlueScreen()
|
||||
|
||||
Filter for Blue Screen objects
|
||||
|
||||
.. attribute:: color
|
||||
blue screen color
|
||||
|
||||
.. attribute:: limits
|
||||
blue screen color limits
|
||||
|
||||
.. attribute:: previous
|
||||
previous pixel filter
|
||||
|
||||
.. class:: FilterColor()
|
||||
|
||||
Filter for color calculations
|
||||
|
||||
.. attribute:: matrix
|
||||
matrix [4][5] for color calculation
|
||||
|
||||
.. attribute:: previous
|
||||
previous pixel filter
|
||||
|
||||
.. class:: FilterGray()
|
||||
|
||||
Filter for gray scale effect
|
||||
|
||||
.. attribute:: previous
|
||||
previous pixel filter
|
||||
|
||||
.. class:: FilterLevel()
|
||||
|
||||
Filter for levels calculations
|
||||
|
||||
.. attribute:: levels
|
||||
levels matrix [4] (min, max)
|
||||
|
||||
.. attribute:: previous
|
||||
previous pixel filter
|
||||
|
||||
.. class:: FilterNormal()
|
||||
|
||||
Filter for Blue Screen objects
|
||||
|
||||
.. attribute:: colorIdx
|
||||
index of color used to calculate normal (0 - red, 1 - green, 2 - blue)
|
||||
|
||||
.. attribute:: depth
|
||||
depth of relief
|
||||
|
||||
.. attribute:: previous
|
||||
previous pixel filter
|
||||
|
||||
.. class:: FilterRGB24()
|
||||
|
||||
Returns a new input filter object to be used with :class:'ImageBuff' object when the image passed
|
||||
to the ImageBuff.load() function has the 3-bytes pixel format BGR.
|
||||
|
||||
.. class:: FilterRGBA32()
|
||||
|
||||
Source filter RGBA32 objects
|
||||
|
||||
.. function:: getLastError()
|
||||
Last error that occurred in a bge.texture function.
|
||||
|
||||
:return: the description of the last error occurred in a bge.texture function.
|
||||
:rtype: string
|
||||
|
||||
.. function:: imageToArray(image,mode)
|
||||
Returns a :class:`~bgl.buffer` corresponding to the current image stored in a texture source object.
|
||||
|
||||
:arg image: Image source object.
|
||||
:type image: object of type :class:'VideoFFmpeg', :class:'ImageFFmpeg', :class:'ImageBuff', :class:'ImageMix', :class:'ImageRender', :class:'ImageMirror' or :class:'ImageViewport'
|
||||
:arg mode: optional argument representing the pixel format.
|
||||
| You can use the characters R, G, B for the 3 color channels, A for the alpha channel,
|
||||
| 0 to force a fixed 0 color channel and 1 to force a fixed 255 color channel.
|
||||
| Example: "BGR" will return 3 bytes per pixel with the Blue, Green and Red channels in that order.
|
||||
| "RGB1" will return 4 bytes per pixel with the Red, Green, Blue channels in that order and the alpha channel forced to 255.
|
||||
| The default mode is "RGBA".
|
||||
|
||||
:type mode: string
|
||||
:rtype: :class:`~bgl.buffer`
|
||||
:return: A object representing the image as one dimensional array of bytes of size (pixel_size*width*height),
|
||||
line by line starting from the bottom of the image. The pixel size and format is determined by the mode
|
||||
parameter.
|
||||
|
||||
.. function materialID(object,name)
|
||||
Returns a numeric value that can be used in :class:'Texture' to create a dynamic texture.
|
||||
|
||||
The value corresponds to an internal material number that uses the texture identified
|
||||
by name. name is a string representing a texture name with IM prefix if you want to
|
||||
identify the texture directly. This method works for basic tex face and for material,
|
||||
provided the material has a texture channel using that particular texture in first
|
||||
position of the texture stack. name can also have MA prefix if you want to identify
|
||||
the texture by material. In that case the material must have a texture channel in first
|
||||
position.
|
||||
|
||||
If the object has no material that matches name, it generates a runtime error. Use try/except to catch the exception.
|
||||
|
||||
Ex: bge.texture.materialID(obj, 'IMvideo.png')
|
||||
|
||||
:arg object: the game object that uses the texture you want to make dynamic
|
||||
:type object: game object
|
||||
:arg name: name of the texture/material you want to make dynamic.
|
||||
:type name: string
|
||||
:rtype: integer
|
||||
|
||||
.. function setLogFile(filename)
|
||||
Sets the name of a text file in which runtime error messages will be written, in addition to the printing
|
||||
of the messages on the Python console. Only the runtime errors specific to the VideoTexture module
|
||||
are written in that file, ordinary runtime time errors are not written.
|
||||
|
||||
:arg filename: name of error log file
|
||||
:type filename: string
|
||||
:rtype: integer
|
@ -1498,15 +1498,18 @@ GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr)
|
||||
GHOST_TInt32 x_mouse= mousePos.x;
|
||||
GHOST_TInt32 y_mouse= mousePos.y;
|
||||
GHOST_TInt32 x_accum, y_accum, x_cur, y_cur, x, y;
|
||||
GHOST_Rect bounds, correctedBounds;
|
||||
GHOST_Rect bounds, windowBounds, correctedBounds;
|
||||
|
||||
/* fallback to window bounds */
|
||||
if(window->getCursorGrabBounds(bounds)==GHOST_kFailure)
|
||||
window->getClientBounds(bounds);
|
||||
|
||||
//Switch back to Cocoa coordinates orientation (y=0 at botton,the same as blender internal btw!), and to client coordinates
|
||||
window->screenToClient(bounds.m_l, bounds.m_b, correctedBounds.m_l, correctedBounds.m_b);
|
||||
window->screenToClient(bounds.m_r, bounds.m_t, correctedBounds.m_r, correctedBounds.m_t);
|
||||
window->getClientBounds(windowBounds);
|
||||
window->screenToClient(bounds.m_l, bounds.m_b, correctedBounds.m_l, correctedBounds.m_t);
|
||||
window->screenToClient(bounds.m_r, bounds.m_t, correctedBounds.m_r, correctedBounds.m_b);
|
||||
correctedBounds.m_b = (windowBounds.m_b - windowBounds.m_t) - correctedBounds.m_b;
|
||||
correctedBounds.m_t = (windowBounds.m_b - windowBounds.m_t) - correctedBounds.m_t;
|
||||
|
||||
//Update accumulation counts
|
||||
window->getCursorGrabAccum(x_accum, y_accum);
|
||||
|
@ -1175,7 +1175,9 @@ convertXKey(
|
||||
GXMAP(type,XF86XK_AudioPrev, GHOST_kKeyMediaFirst);
|
||||
GXMAP(type,XF86XK_AudioRewind, GHOST_kKeyMediaFirst);
|
||||
GXMAP(type,XF86XK_AudioNext, GHOST_kKeyMediaLast);
|
||||
#ifdef XF86XK_AudioForward /* Debian lenny's XF86keysym.h has no XF86XK_AudioForward define */
|
||||
GXMAP(type,XF86XK_AudioForward, GHOST_kKeyMediaLast);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* some extra sun cruft (NICE KEYBOARD!) */
|
||||
|
123
intern/ghost/test/CMakeLists.txt
Normal file
123
intern/ghost/test/CMakeLists.txt
Normal file
@ -0,0 +1,123 @@
|
||||
|
||||
cmake_policy(SET CMP0003 NEW)
|
||||
cmake_policy(SET CMP0005 NEW)
|
||||
|
||||
cmake_minimum_required(VERSION 2.8)
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Macros
|
||||
|
||||
|
||||
# stub macro, does nothing
|
||||
macro(blender_add_lib
|
||||
name
|
||||
sources
|
||||
includes
|
||||
includes_sys
|
||||
)
|
||||
|
||||
endmacro()
|
||||
|
||||
# suffix relative paths so we can use external cmake files
|
||||
macro(suffix_relpaths
|
||||
new_files files prefix)
|
||||
|
||||
set(${new_files})
|
||||
foreach(_file ${files})
|
||||
if(IS_ABSOLUTE _file)
|
||||
list(APPEND ${new_files} ${_file})
|
||||
else()
|
||||
list(APPEND ${new_files} "${prefix}${_file}")
|
||||
endif()
|
||||
endforeach()
|
||||
unset(_file)
|
||||
endmacro()
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Libraries
|
||||
|
||||
# ghost
|
||||
include(${CMAKE_SOURCE_DIR}/../CMakeLists.txt)
|
||||
suffix_relpaths(INC_NEW "${INC}" "../")
|
||||
suffix_relpaths(SRC_NEW "${SRC}" "../")
|
||||
include_directories(${INC_NEW})
|
||||
add_library(ghost_lib ${SRC_NEW})
|
||||
|
||||
# string
|
||||
include(${CMAKE_SOURCE_DIR}/../../string/CMakeLists.txt)
|
||||
suffix_relpaths(INC_NEW "${INC}" "../../string/")
|
||||
suffix_relpaths(SRC_NEW "${SRC}" "../../string/")
|
||||
include_directories(${INC_NEW})
|
||||
add_library(string_lib ${SRC_NEW})
|
||||
|
||||
# guardedalloc
|
||||
include(${CMAKE_SOURCE_DIR}/../../guardedalloc/CMakeLists.txt)
|
||||
suffix_relpaths(INC_NEW "${INC}" "../../guardedalloc/")
|
||||
suffix_relpaths(SRC_NEW "${SRC}" "../../guardedalloc/")
|
||||
include_directories(${INC_NEW})
|
||||
add_library(guardedalloc_lib ${SRC_NEW})
|
||||
|
||||
|
||||
find_package(OpenGL REQUIRED)
|
||||
|
||||
include_directories(${CMAKE_SOURCE_DIR}/../)
|
||||
include_directories(${OPENGL_INCLUDE_DIR})
|
||||
|
||||
if(UNIX AND NOT APPLE)
|
||||
find_package(X11 REQUIRED)
|
||||
|
||||
set(PLATFORM_LINKLIBS
|
||||
${X11_X11_LIB}
|
||||
${X11_Xinput_LIB}
|
||||
)
|
||||
endif()
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Executables
|
||||
|
||||
|
||||
# Gears (C)
|
||||
add_executable(gears_c
|
||||
${CMAKE_SOURCE_DIR}/gears/GHOST_C-Test.c)
|
||||
|
||||
target_link_libraries(gears_c
|
||||
ghost_lib
|
||||
string_lib
|
||||
${OPENGL_gl_LIBRARY}
|
||||
${OPENGL_glu_LIBRARY}
|
||||
${PLATFORM_LINKLIBS}
|
||||
)
|
||||
|
||||
|
||||
# Gears (C++)
|
||||
add_executable(gears_cpp
|
||||
${CMAKE_SOURCE_DIR}/gears/GHOST_Test.cpp)
|
||||
|
||||
target_link_libraries(gears_cpp
|
||||
ghost_lib
|
||||
string_lib
|
||||
${OPENGL_gl_LIBRARY}
|
||||
${OPENGL_glu_LIBRARY}
|
||||
${PLATFORM_LINKLIBS}
|
||||
)
|
||||
|
||||
|
||||
# MultiTest (C)
|
||||
add_executable(multitest_c
|
||||
${CMAKE_SOURCE_DIR}/multitest/Basic.c
|
||||
${CMAKE_SOURCE_DIR}/multitest/EventToBuf.c
|
||||
${CMAKE_SOURCE_DIR}/multitest/MultiTest.c
|
||||
${CMAKE_SOURCE_DIR}/multitest/ScrollBar.c
|
||||
${CMAKE_SOURCE_DIR}/multitest/Util.c
|
||||
${CMAKE_SOURCE_DIR}/multitest/WindowData.c
|
||||
)
|
||||
|
||||
target_link_libraries(multitest_c
|
||||
ghost_lib
|
||||
string_lib
|
||||
guardedalloc_lib
|
||||
${OPENGL_gl_LIBRARY}
|
||||
${OPENGL_glu_LIBRARY}
|
||||
${PLATFORM_LINKLIBS}
|
||||
)
|
@ -474,6 +474,7 @@ int main(int argc, char** argv)
|
||||
200,
|
||||
GHOST_kWindowStateNormal,
|
||||
GHOST_kDrawingContextTypeOpenGL,
|
||||
FALSE,
|
||||
FALSE);
|
||||
if (!sMainWindow)
|
||||
{
|
||||
@ -490,6 +491,7 @@ int main(int argc, char** argv)
|
||||
200,
|
||||
GHOST_kWindowStateNormal,
|
||||
GHOST_kDrawingContextTypeOpenGL,
|
||||
FALSE,
|
||||
FALSE);
|
||||
if (!sSecondaryWindow)
|
||||
{
|
||||
|
@ -428,7 +428,7 @@ Application::Application(GHOST_ISystem* system)
|
||||
// Create the main window
|
||||
STR_String title1 ("gears - main window");
|
||||
m_mainWindow = system->createWindow(title1, 10, 64, 320, 200, GHOST_kWindowStateNormal,
|
||||
GHOST_kDrawingContextTypeOpenGL, true /* stereo flag */);
|
||||
GHOST_kDrawingContextTypeOpenGL, false, false);
|
||||
|
||||
if (!m_mainWindow) {
|
||||
std::cout << "could not create main window\n";
|
||||
@ -438,7 +438,7 @@ Application::Application(GHOST_ISystem* system)
|
||||
// Create a secondary window
|
||||
STR_String title2 ("gears - secondary window");
|
||||
m_secondaryWindow = system->createWindow(title2, 340, 64, 320, 200, GHOST_kWindowStateNormal,
|
||||
GHOST_kDrawingContextTypeOpenGL, false /* stereo flag */);
|
||||
GHOST_kDrawingContextTypeOpenGL, false, false);
|
||||
if (!m_secondaryWindow) {
|
||||
cout << "could not create secondary window\n";
|
||||
exit(-1);
|
||||
|
@ -45,6 +45,11 @@
|
||||
|
||||
#include <MERSENNETWISTER.h>
|
||||
|
||||
#ifdef WIN32
|
||||
#include <float.h>
|
||||
#define isnan _isnan
|
||||
#endif
|
||||
|
||||
// Tile file header, update revision upon any change done to the noise generator
|
||||
static const char tilefile_headerstring[] = "Noise Tile File rev. ";
|
||||
static const char tilefile_revision[] = "001";
|
||||
@ -69,7 +74,7 @@ static void downsampleX(float *from, float *to, int n){
|
||||
const float *a = &downCoeffs[16];
|
||||
for (int i = 0; i < n / 2; i++) {
|
||||
to[i] = 0;
|
||||
for (int k = 2 * i - 16; k <= 2 * i + 16; k++)
|
||||
for (int k = 2 * i - 16; k < 2 * i + 16; k++)
|
||||
to[i] += a[k - 2 * i] * from[modFast128(k)];
|
||||
}
|
||||
}
|
||||
@ -79,7 +84,7 @@ static void downsampleY(float *from, float *to, int n){
|
||||
const float *a = &downCoeffs[16];
|
||||
for (int i = 0; i < n / 2; i++) {
|
||||
to[i * n] = 0;
|
||||
for (int k = 2 * i - 16; k <= 2 * i + 16; k++)
|
||||
for (int k = 2 * i - 16; k < 2 * i + 16; k++)
|
||||
to[i * n] += a[k - 2 * i] * from[modFast128(k) * n];
|
||||
}
|
||||
}
|
||||
@ -89,7 +94,7 @@ static void downsampleZ(float *from, float *to, int n){
|
||||
const float *a = &downCoeffs[16];
|
||||
for (int i = 0; i < n / 2; i++) {
|
||||
to[i * n * n] = 0;
|
||||
for (int k = 2 * i - 16; k <= 2 * i + 16; k++)
|
||||
for (int k = 2 * i - 16; k < 2 * i + 16; k++)
|
||||
to[i * n * n] += a[k - 2 * i] * from[modFast128(k) * n * n];
|
||||
}
|
||||
}
|
||||
@ -262,6 +267,14 @@ static bool loadTile(float* const noiseTileData, std::string filename)
|
||||
printf("loadTile: Noise tile '%s' is wrong size %d.\n", filename.c_str(), (int)bread);
|
||||
return false;
|
||||
}
|
||||
|
||||
// check for invalid nan tile data that could be generated. bug is now
|
||||
// fixed, but invalid files may still hang around
|
||||
if (isnan(noiseTileData[0])) {
|
||||
printf("loadTile: Noise tile '%s' contains nan values.\n", filename.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -105,9 +105,9 @@ def edge_face_count(mesh):
|
||||
:return: list face users for each item in mesh.edges.
|
||||
:rtype: list
|
||||
"""
|
||||
edge_face_count_dict = edge_face_count_dict(mesh)
|
||||
edge_face_count = edge_face_count_dict(mesh)
|
||||
get = dict.get
|
||||
return [get(edge_face_count_dict, ed.key, 0) for ed in mesh.edges]
|
||||
return [get(edge_face_count, ed.key, 0) for ed in mesh.edges]
|
||||
|
||||
|
||||
def edge_loops_from_faces(mesh, faces=None, seams=()):
|
||||
|
@ -290,9 +290,8 @@ class DATA_PT_texface(MeshButtonsPanel, bpy.types.Panel):
|
||||
|
||||
@classmethod
|
||||
def poll(cls, context):
|
||||
ob = context.active_object
|
||||
|
||||
return (context.mode == 'EDIT_MESH') and ob and ob.type == 'MESH'
|
||||
obj = context.object
|
||||
return (context.mode == 'EDIT_MESH') and obj and obj.type == 'MESH'
|
||||
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
|
@ -729,6 +729,7 @@ class MATERIAL_PT_options(MaterialButtonsPanel, bpy.types.Panel):
|
||||
col.prop(mat, "use_vertex_color_paint")
|
||||
col.prop(mat, "use_vertex_color_light")
|
||||
col.prop(mat, "use_object_color")
|
||||
col.prop(mat, "pass_index")
|
||||
|
||||
|
||||
class MATERIAL_PT_shadow(MaterialButtonsPanel, bpy.types.Panel):
|
||||
|
@ -141,6 +141,7 @@ class RENDER_PT_layers(RenderButtonsPanel, bpy.types.Panel):
|
||||
col.prop(rl, "use_pass_uv")
|
||||
col.prop(rl, "use_pass_mist")
|
||||
col.prop(rl, "use_pass_object_index")
|
||||
col.prop(rl, "use_pass_material_index")
|
||||
col.prop(rl, "use_pass_color")
|
||||
|
||||
col = split.column()
|
||||
|
@ -55,11 +55,12 @@
|
||||
#ifndef __AVI_H__
|
||||
#define __AVI_H__
|
||||
|
||||
#include "MEM_sys_types.h"
|
||||
#include <stdio.h> /* for FILE */
|
||||
|
||||
typedef struct _AviChunk {
|
||||
int fcc;
|
||||
int size;
|
||||
int64_t size;
|
||||
} AviChunk;
|
||||
|
||||
typedef struct _AviList {
|
||||
@ -185,16 +186,16 @@ typedef struct _AviMovie {
|
||||
#define AVI_MOVIE_READ 0
|
||||
#define AVI_MOVIE_WRITE 1
|
||||
|
||||
unsigned long size;
|
||||
int64_t size;
|
||||
|
||||
AviMainHeader *header;
|
||||
AviStreamRec *streams;
|
||||
AviIndexEntry *entries;
|
||||
int index_entries;
|
||||
|
||||
int movi_offset;
|
||||
int read_offset;
|
||||
long *offset_table;
|
||||
int64_t movi_offset;
|
||||
int64_t read_offset;
|
||||
int64_t *offset_table;
|
||||
|
||||
/* Local data goes here */
|
||||
int interlace;
|
||||
|
@ -27,6 +27,7 @@
|
||||
set(INC
|
||||
.
|
||||
../../../intern/guardedalloc
|
||||
../blenlib
|
||||
)
|
||||
|
||||
set(INC_SYS
|
||||
|
@ -3,7 +3,7 @@ Import ('env')
|
||||
|
||||
sources = env.Glob('intern/*.c')
|
||||
|
||||
incs = '. #/intern/guardedalloc'
|
||||
incs = '. #/intern/guardedalloc ../blenlib'
|
||||
incs += ' ' + env['BF_JPEG_INC']
|
||||
|
||||
env.BlenderLib ('bf_avi', sources, Split(incs), [], libtype=['core','player'], priority = [190,120] )
|
||||
|
@ -42,6 +42,9 @@
|
||||
#include <ctype.h>
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
#include "MEM_sys_types.h"
|
||||
|
||||
#include "BLI_winstuff.h"
|
||||
|
||||
#include "AVI_avi.h"
|
||||
#include "avi_intern.h"
|
||||
@ -593,7 +596,6 @@ AviError AVI_open_movie (const char *name, AviMovie *movie) {
|
||||
|
||||
movie->movi_offset = ftell (movie->fp);
|
||||
movie->read_offset = movie->movi_offset;
|
||||
if (AVI_DEBUG) printf ("movi_offset is %d\n", movie->movi_offset);
|
||||
|
||||
/* Read in the index if the file has one, otherwise create one */
|
||||
if (movie->header->Flags & AVIF_HASINDEX) {
|
||||
@ -707,8 +709,8 @@ AviError AVI_open_compress (char *name, AviMovie *movie, int streams, ...) {
|
||||
AviList list;
|
||||
AviChunk chunk;
|
||||
int i;
|
||||
int header_pos1, header_pos2;
|
||||
int stream_pos1, stream_pos2;
|
||||
int64_t header_pos1, header_pos2;
|
||||
int64_t stream_pos1, stream_pos2;
|
||||
|
||||
movie->type = AVI_MOVIE_WRITE;
|
||||
movie->fp = fopen (name, "wb");
|
||||
@ -718,7 +720,7 @@ AviError AVI_open_compress (char *name, AviMovie *movie, int streams, ...) {
|
||||
if (movie->fp == NULL)
|
||||
return AVI_ERROR_OPEN;
|
||||
|
||||
movie->offset_table = (long *) MEM_mallocN ((1+streams*2) * sizeof (long),"offsettable");
|
||||
movie->offset_table = (int64_t *) MEM_mallocN ((1+streams*2) * sizeof (int64_t),"offsettable");
|
||||
|
||||
for (i=0; i < 1 + streams*2; i++)
|
||||
movie->offset_table[i] = -1L;
|
||||
@ -897,7 +899,7 @@ AviError AVI_write_frame (AviMovie *movie, int frame_num, ...) {
|
||||
AviIndexEntry *temp;
|
||||
va_list ap;
|
||||
int stream;
|
||||
long rec_off;
|
||||
int64_t rec_off;
|
||||
AviFormat format;
|
||||
void *buffer;
|
||||
int size;
|
||||
|
@ -40,6 +40,8 @@
|
||||
#include "avi_intern.h"
|
||||
#include "endian.h"
|
||||
|
||||
#include "BLI_winstuff.h"
|
||||
|
||||
/* avi_set_compress_options gets its own file... now don't WE feel important? */
|
||||
|
||||
AviError AVI_set_compress_option (AviMovie *movie, int option_type, int stream, AviOption option, void *opt_data) {
|
||||
|
@ -88,6 +88,7 @@ typedef struct bNodeType {
|
||||
|
||||
/* this line is set on startup of blender */
|
||||
void (*uifunc)(struct uiLayout *, struct bContext *C, struct PointerRNA *ptr);
|
||||
void (*uifuncbut)(struct uiLayout *, struct bContext *C, struct PointerRNA *ptr);
|
||||
const char *(*labelfunc)(struct bNode *);
|
||||
|
||||
void (*initfunc)(struct bNode *);
|
||||
@ -319,9 +320,10 @@ void ntreeGPUMaterialNodes(struct bNodeTree *ntree, struct GPUMaterial *mat);
|
||||
#define RRES_OUT_REFRACT 12
|
||||
#define RRES_OUT_INDIRECT 13
|
||||
#define RRES_OUT_INDEXOB 14
|
||||
#define RRES_OUT_MIST 15
|
||||
#define RRES_OUT_EMIT 16
|
||||
#define RRES_OUT_ENV 17
|
||||
#define RRES_OUT_INDEXMA 15
|
||||
#define RRES_OUT_MIST 16
|
||||
#define RRES_OUT_EMIT 17
|
||||
#define RRES_OUT_ENV 18
|
||||
|
||||
/* note: types are needed to restore callbacks, don't change values */
|
||||
#define CMP_NODE_VIEWER 201
|
||||
|
@ -1002,7 +1002,7 @@ static BME_Mesh *BME_bevel_initialize(BME_Mesh *bm, int options, int UNUSED(defg
|
||||
}
|
||||
|
||||
/* edge pass */
|
||||
threshold = (float)cos((angle + 0.00001) * M_PI / 180.0);
|
||||
threshold = (float)cos((angle + 0.001) * M_PI / 180.0);
|
||||
for (e=bm->edges.first; e; e=e->next) {
|
||||
e->tflag1 = BME_BEVEL_ORIG;
|
||||
weight = 0.0;
|
||||
|
@ -719,12 +719,13 @@ static void group_duplilist(ListBase *lb, Scene *scene, Object *ob, int level, i
|
||||
/* note, if you check on layer here, render goes wrong... it still deforms verts and uses parent imat */
|
||||
if(go->ob!=ob) {
|
||||
|
||||
/* Group Dupli Offset, should apply after everything else */
|
||||
if (group->dupli_ofs[0] || group->dupli_ofs[1] || group->dupli_ofs[2]) {
|
||||
/* group dupli offset, should apply after everything else */
|
||||
if(!is_zero_v3(group->dupli_ofs)) {
|
||||
copy_m4_m4(tmat, go->ob->obmat);
|
||||
sub_v3_v3v3(tmat[3], tmat[3], group->dupli_ofs);
|
||||
mul_m4_m4m4(mat, tmat, ob->obmat);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
mul_m4_m4m4(mat, go->ob->obmat, ob->obmat);
|
||||
}
|
||||
|
||||
@ -1395,7 +1396,17 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p
|
||||
|
||||
if(part->ren_as==PART_DRAW_GR && psys->part->draw & PART_DRAW_WHOLE_GR) {
|
||||
for(go= part->dup_group->gobject.first, b=0; go; go= go->next, b++) {
|
||||
|
||||
/* group dupli offset, should apply after everything else */
|
||||
if(!is_zero_v3(part->dup_group->dupli_ofs)) {
|
||||
copy_m4_m4(tmat, oblist[b]->obmat);
|
||||
sub_v3_v3v3(tmat[3], tmat[3], part->dup_group->dupli_ofs);
|
||||
mul_m4_m4m4(tmat, tmat, pamat);
|
||||
}
|
||||
else {
|
||||
mul_m4_m4m4(tmat, oblist[b]->obmat, pamat);
|
||||
}
|
||||
|
||||
mul_mat3_m4_fl(tmat, size*scale);
|
||||
if(par_space_mat)
|
||||
mul_m4_m4m4(mat, tmat, par_space_mat);
|
||||
|
@ -867,6 +867,10 @@ static void do_init_render_material(Material *ma, int r_mode, float *amb)
|
||||
|
||||
if(ma->strand_surfnor > 0.0f)
|
||||
ma->mode_l |= MA_STR_SURFDIFF;
|
||||
|
||||
/* parses the geom+tex nodes */
|
||||
if(ma->nodetree && ma->use_nodes)
|
||||
ntreeShaderGetTexcoMode(ma->nodetree, r_mode, &ma->texco, &ma->mode_l);
|
||||
}
|
||||
|
||||
static void init_render_nodetree(bNodeTree *ntree, Material *basemat, int r_mode, float *amb)
|
||||
@ -887,8 +891,6 @@ static void init_render_nodetree(bNodeTree *ntree, Material *basemat, int r_mode
|
||||
init_render_nodetree((bNodeTree *)node->id, basemat, r_mode, amb);
|
||||
}
|
||||
}
|
||||
/* parses the geom+tex nodes */
|
||||
ntreeShaderGetTexcoMode(ntree, r_mode, &basemat->texco, &basemat->mode_l);
|
||||
}
|
||||
|
||||
void init_render_material(Material *mat, int r_mode, float *amb)
|
||||
|
@ -3156,6 +3156,8 @@ static void force_hidden_passes(bNode *node, int passflag)
|
||||
if(!(passflag & SCE_PASS_INDIRECT)) sock->flag |= SOCK_UNAVAIL;
|
||||
sock= BLI_findlink(&node->outputs, RRES_OUT_INDEXOB);
|
||||
if(!(passflag & SCE_PASS_INDEXOB)) sock->flag |= SOCK_UNAVAIL;
|
||||
sock= BLI_findlink(&node->outputs, RRES_OUT_INDEXMA);
|
||||
if(!(passflag & SCE_PASS_INDEXMA)) sock->flag |= SOCK_UNAVAIL;
|
||||
sock= BLI_findlink(&node->outputs, RRES_OUT_MIST);
|
||||
if(!(passflag & SCE_PASS_MIST)) sock->flag |= SOCK_UNAVAIL;
|
||||
sock= BLI_findlink(&node->outputs, RRES_OUT_EMIT);
|
||||
|
@ -3670,7 +3670,7 @@ static void dynamics_step(ParticleSimulationData *sim, float cfra)
|
||||
pa->size *= 1.0f - part->randsize * PSYS_FRAND(p + 1);
|
||||
|
||||
birthtime = pa->time;
|
||||
dietime = birthtime + pa->lifetime;
|
||||
dietime = pa->dietime;
|
||||
|
||||
/* store this, so we can do multiple loops over particles */
|
||||
pa->state.time = dfra;
|
||||
|
@ -2124,7 +2124,8 @@ void BKE_ptcache_id_time(PTCacheID *pid, Scene *scene, float cfra, int *startfra
|
||||
{
|
||||
Object *ob;
|
||||
PointCache *cache;
|
||||
float offset, time, nexttime;
|
||||
/* float offset; unused for now */
|
||||
float time, nexttime;
|
||||
|
||||
/* TODO: this has to be sorter out once bsystem_time gets redone, */
|
||||
/* now caches can handle interpolating etc. too - jahka */
|
||||
@ -2152,13 +2153,18 @@ void BKE_ptcache_id_time(PTCacheID *pid, Scene *scene, float cfra, int *startfra
|
||||
*startframe= cache->startframe;
|
||||
*endframe= cache->endframe;
|
||||
|
||||
// XXX ipoflag is depreceated - old animation system stuff
|
||||
if (/*(ob->ipoflag & OB_OFFS_PARENT) &&*/ (ob->partype & PARSLOW)==0) {
|
||||
/* TODO: time handling with object offsets and simulated vs. cached
|
||||
* particles isn't particularly easy, so for now what you see is what
|
||||
* you get. In the future point cache could handle the whole particle
|
||||
* system timing. */
|
||||
#if 0
|
||||
if ((ob->partype & PARSLOW)==0) {
|
||||
offset= give_timeoffset(ob);
|
||||
|
||||
*startframe += (int)(offset+0.5f);
|
||||
*endframe += (int)(offset+0.5f);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/* verify cached_frames array is up to date */
|
||||
|
@ -39,6 +39,10 @@
|
||||
#include <math.h>
|
||||
#include "BLI_math_inline.h"
|
||||
|
||||
#ifdef __sun__
|
||||
#include <ieeefp.h> /* for finite() */
|
||||
#endif
|
||||
|
||||
#ifndef M_PI
|
||||
#define M_PI 3.14159265358979323846
|
||||
#endif
|
||||
|
@ -98,6 +98,15 @@ extern "C" {
|
||||
typedef unsigned int mode_t;
|
||||
#endif
|
||||
|
||||
/* use functions that take a 64 bit offset for files larger than 4GB */
|
||||
#ifndef FREE_WINDOWS
|
||||
#include <stdio.h>
|
||||
#define fseek(stream, offset, origin) _fseeki64(stream, offset, origin)
|
||||
#define ftell(stream) _ftelli64(stream)
|
||||
#define lseek(fd, offset, origin) _lseeki64(fd, offset, origin)
|
||||
#define tell(fd) _telli64(fd)
|
||||
#endif
|
||||
|
||||
/* mingw using _SSIZE_T_ to declare ssize_t type */
|
||||
#ifndef _SSIZE_T_
|
||||
#define _SSIZE_T_
|
||||
|
@ -430,7 +430,7 @@ int isect_line_sphere_v2(const float l1[2], const float l2[2],
|
||||
l2[1] - l1[1]
|
||||
};
|
||||
|
||||
const float a= dot_v3v3(ldir, ldir);
|
||||
const float a= dot_v2v2(ldir, ldir);
|
||||
|
||||
const float b= 2.0f *
|
||||
(ldir[0] * (l1[0] - sp[0]) +
|
||||
|
@ -1024,26 +1024,6 @@ static int get_path_system(char *targetpath, const char *folder_name, const char
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(WIN32) && BLENDER_VERSION < 258
|
||||
|
||||
static int path_have_257_script_install(void)
|
||||
{
|
||||
const int ver= BLENDER_VERSION;
|
||||
char path[FILE_MAX] = "";
|
||||
char system_pyfile[FILE_MAX];
|
||||
|
||||
if (get_path_user(path, "scripts", NULL, "BLENDER_USER_SCRIPTS", ver)) {
|
||||
BLI_join_dirfile(system_pyfile, sizeof(system_pyfile), path, "modules/bpy_types.py");
|
||||
|
||||
if (BLI_exists(system_pyfile))
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/* get a folder out of the 'folder_id' presets for paths */
|
||||
/* returns the path if found, NULL string if not */
|
||||
char *BLI_get_folder(int folder_id, const char *subfolder)
|
||||
@ -1076,20 +1056,7 @@ char *BLI_get_folder(int folder_id, const char *subfolder)
|
||||
return NULL;
|
||||
|
||||
case BLENDER_USER_SCRIPTS:
|
||||
#if defined(WIN32) && BLENDER_VERSION < 258
|
||||
/* if we have a 2.57 installation, then we may have system script
|
||||
* files in the user configuration folder. avoid using that folder
|
||||
* if they are there, until the version gets bumped to 2.58, so
|
||||
* we can be sure that folder only has addons etc. */
|
||||
if (path_have_257_script_install()) {
|
||||
if (get_path_local(path, "scripts", subfolder, ver)) break;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
if (get_path_user(path, "scripts", subfolder, "BLENDER_USER_SCRIPTS", ver)) break;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
|
||||
case BLENDER_SYSTEM_SCRIPTS:
|
||||
|
@ -478,7 +478,7 @@ LinkNode *BLI_read_file_as_lines(const char *name)
|
||||
FILE *fp= fopen(name, "r");
|
||||
LinkNode *lines= NULL;
|
||||
char *buf;
|
||||
int size;
|
||||
int64_t size;
|
||||
|
||||
if (!fp) return NULL;
|
||||
|
||||
|
@ -70,7 +70,7 @@ void project_from_camera(float target[2], float source[3], UvCameraInfo *uci)
|
||||
vec2d[0]= pv4[0];
|
||||
vec2d[1]= pv4[2];
|
||||
target[0]= angle * ((float)M_PI / uci->camangle);
|
||||
target[1]= pv4[1] / (len_v2(vec2d) * uci->camsize);
|
||||
target[1]= pv4[1] / (len_v2(vec2d) * (uci->camsize * 2.0f));
|
||||
}
|
||||
}
|
||||
else {
|
||||
@ -146,7 +146,11 @@ UvCameraInfo *project_camera_info(Object *ob, float (*rotmat)[4], float winx, fl
|
||||
uci.camangle= lens_to_angle(camera->lens) / 2.0f;
|
||||
uci.camsize= uci.do_persp ? tanf(uci.camangle) : camera->ortho_scale;
|
||||
|
||||
if (invert_m4_m4(uci.caminv, ob->obmat)) {
|
||||
/* account for scaled cameras */
|
||||
copy_m4_m4(uci.caminv, ob->obmat);
|
||||
normalize_m4(uci.caminv);
|
||||
|
||||
if (invert_m4(uci.caminv)) {
|
||||
UvCameraInfo *uci_pt;
|
||||
|
||||
/* normal projection */
|
||||
@ -169,8 +173,8 @@ UvCameraInfo *project_camera_info(Object *ob, float (*rotmat)[4], float winx, fl
|
||||
}
|
||||
|
||||
/* include 0.5f here to move the UVs into the center */
|
||||
uci.shiftx = 0.5f - camera->shiftx;
|
||||
uci.shifty = 0.5f - camera->shifty;
|
||||
uci.shiftx = 0.5f - (camera->shiftx * uci.xasp);
|
||||
uci.shifty = 0.5f - (camera->shifty * uci.yasp);
|
||||
|
||||
uci_pt= MEM_mallocN(sizeof(UvCameraInfo), "UvCameraInfo");
|
||||
*uci_pt= uci;
|
||||
|
@ -89,14 +89,14 @@ void ArmatureExporter::add_instance_controller(Object *ob)
|
||||
ins.add();
|
||||
}
|
||||
|
||||
void ArmatureExporter::export_controllers(Scene *sce)
|
||||
void ArmatureExporter::export_controllers(Scene *sce, bool export_selected)
|
||||
{
|
||||
scene = sce;
|
||||
|
||||
openLibrary();
|
||||
|
||||
GeometryFunctor gf;
|
||||
gf.forEachMeshObjectInScene<ArmatureExporter>(sce, *this);
|
||||
gf.forEachMeshObjectInScene<ArmatureExporter>(sce, *this, export_selected);
|
||||
|
||||
closeLibrary();
|
||||
}
|
||||
@ -351,12 +351,17 @@ std::string ArmatureExporter::add_inv_bind_mats_source(Object *ob_arm, ListBase
|
||||
|
||||
bPoseChannel *pchan = get_pose_channel(pose, def->name);
|
||||
|
||||
float pose_mat[4][4];
|
||||
float mat[4][4];
|
||||
float world[4][4];
|
||||
float inv_bind_mat[4][4];
|
||||
|
||||
// pose_mat is the same as pchan->pose_mat, but without the rotation
|
||||
unit_m4(pose_mat);
|
||||
translate_m4(pose_mat, pchan->pose_head[0], pchan->pose_head[1], pchan->pose_head[2]);
|
||||
|
||||
// make world-space matrix, pose_mat is armature-space
|
||||
mul_m4_m4m4(world, pchan->pose_mat, ob_arm->obmat);
|
||||
mul_m4_m4m4(world, pose_mat, ob_arm->obmat);
|
||||
|
||||
invert_m4_m4(mat, world);
|
||||
converter.mat4_to_dae(inv_bind_mat, mat);
|
||||
|
@ -65,7 +65,7 @@ public:
|
||||
|
||||
void add_instance_controller(Object *ob);
|
||||
|
||||
void export_controllers(Scene *sce);
|
||||
void export_controllers(Scene *sce, bool export_selected);
|
||||
|
||||
void operator()(Object *ob);
|
||||
|
||||
|
@ -42,24 +42,25 @@
|
||||
CamerasExporter::CamerasExporter(COLLADASW::StreamWriter *sw): COLLADASW::LibraryCameras(sw){}
|
||||
|
||||
template<class Functor>
|
||||
void forEachCameraObjectInScene(Scene *sce, Functor &f)
|
||||
void forEachCameraObjectInScene(Scene *sce, Functor &f, bool export_selected)
|
||||
{
|
||||
Base *base= (Base*) sce->base.first;
|
||||
while(base) {
|
||||
Object *ob = base->object;
|
||||
|
||||
if (ob->type == OB_CAMERA && ob->data) {
|
||||
if (ob->type == OB_CAMERA && ob->data
|
||||
&& !(export_selected && !(ob->flag & SELECT))) {
|
||||
f(ob, sce);
|
||||
}
|
||||
base= base->next;
|
||||
}
|
||||
}
|
||||
|
||||
void CamerasExporter::exportCameras(Scene *sce)
|
||||
void CamerasExporter::exportCameras(Scene *sce, bool export_selected)
|
||||
{
|
||||
openLibrary();
|
||||
|
||||
forEachCameraObjectInScene(sce, *this);
|
||||
forEachCameraObjectInScene(sce, *this, export_selected);
|
||||
|
||||
closeLibrary();
|
||||
}
|
||||
|
@ -40,7 +40,7 @@ class CamerasExporter: COLLADASW::LibraryCameras
|
||||
{
|
||||
public:
|
||||
CamerasExporter(COLLADASW::StreamWriter *sw);
|
||||
void exportCameras(Scene *sce);
|
||||
void exportCameras(Scene *sce, bool export_selected);
|
||||
void operator()(Object *ob, Scene *sce);
|
||||
};
|
||||
|
||||
|
@ -170,7 +170,7 @@ public:
|
||||
SceneExporter(COLLADASW::StreamWriter *sw, ArmatureExporter *arm) : COLLADASW::LibraryVisualScenes(sw),
|
||||
arm_exporter(arm) {}
|
||||
|
||||
void exportScene(Scene *sce) {
|
||||
void exportScene(Scene *sce, bool export_selected) {
|
||||
// <library_visual_scenes> <visual_scene>
|
||||
std::string id_naming = id_name(sce);
|
||||
openVisualScene(translate_id(id_naming), id_naming);
|
||||
@ -179,7 +179,7 @@ public:
|
||||
//forEachMeshObjectInScene(sce, *this);
|
||||
//forEachCameraObjectInScene(sce, *this);
|
||||
//forEachLampObjectInScene(sce, *this);
|
||||
exportHierarchy(sce);
|
||||
exportHierarchy(sce, export_selected);
|
||||
|
||||
// </visual_scene> </library_visual_scenes>
|
||||
closeVisualScene();
|
||||
@ -187,7 +187,7 @@ public:
|
||||
closeLibrary();
|
||||
}
|
||||
|
||||
void exportHierarchy(Scene *sce)
|
||||
void exportHierarchy(Scene *sce, bool export_selected)
|
||||
{
|
||||
Base *base= (Base*) sce->base.first;
|
||||
while(base) {
|
||||
@ -198,8 +198,11 @@ public:
|
||||
case OB_MESH:
|
||||
case OB_CAMERA:
|
||||
case OB_LAMP:
|
||||
case OB_EMPTY:
|
||||
case OB_ARMATURE:
|
||||
case OB_EMPTY:
|
||||
if (export_selected && !(ob->flag & SELECT)) {
|
||||
break;
|
||||
}
|
||||
// write nodes....
|
||||
writeNodes(ob, sce);
|
||||
break;
|
||||
@ -929,7 +932,7 @@ protected:
|
||||
}
|
||||
};
|
||||
|
||||
void DocumentExporter::exportCurrentScene(Scene *sce, const char* filename)
|
||||
void DocumentExporter::exportCurrentScene(Scene *sce, const char* filename, bool selected)
|
||||
{
|
||||
PointerRNA sceneptr, unit_settings;
|
||||
PropertyRNA *system; /* unused , *scale; */
|
||||
@ -1011,31 +1014,31 @@ void DocumentExporter::exportCurrentScene(Scene *sce, const char* filename)
|
||||
// <library_cameras>
|
||||
if(has_object_type(sce, OB_CAMERA)) {
|
||||
CamerasExporter ce(&sw);
|
||||
ce.exportCameras(sce);
|
||||
ce.exportCameras(sce, selected);
|
||||
}
|
||||
|
||||
// <library_lights>
|
||||
if(has_object_type(sce, OB_LAMP)) {
|
||||
LightsExporter le(&sw);
|
||||
le.exportLights(sce);
|
||||
le.exportLights(sce, selected);
|
||||
}
|
||||
|
||||
// <library_images>
|
||||
ImagesExporter ie(&sw, filename);
|
||||
ie.exportImages(sce);
|
||||
ie.exportImages(sce, selected);
|
||||
|
||||
// <library_effects>
|
||||
EffectsExporter ee(&sw);
|
||||
ee.exportEffects(sce);
|
||||
ee.exportEffects(sce, selected);
|
||||
|
||||
// <library_materials>
|
||||
MaterialsExporter me(&sw);
|
||||
me.exportMaterials(sce);
|
||||
me.exportMaterials(sce, selected);
|
||||
|
||||
// <library_geometries>
|
||||
if(has_object_type(sce, OB_MESH)) {
|
||||
GeometryExporter ge(&sw);
|
||||
ge.exportGeom(sce);
|
||||
ge.exportGeom(sce, selected);
|
||||
}
|
||||
|
||||
// <library_animations>
|
||||
@ -1045,12 +1048,12 @@ void DocumentExporter::exportCurrentScene(Scene *sce, const char* filename)
|
||||
// <library_controllers>
|
||||
ArmatureExporter arm_exporter(&sw);
|
||||
if(has_object_type(sce, OB_ARMATURE)) {
|
||||
arm_exporter.export_controllers(sce);
|
||||
arm_exporter.export_controllers(sce, selected);
|
||||
}
|
||||
|
||||
// <library_visual_scenes>
|
||||
SceneExporter se(&sw, &arm_exporter);
|
||||
se.exportScene(sce);
|
||||
se.exportScene(sce, selected);
|
||||
|
||||
// <scene>
|
||||
std::string scene_name(translate_id(id_name(sce)));
|
||||
|
@ -34,7 +34,7 @@ struct Scene;
|
||||
class DocumentExporter
|
||||
{
|
||||
public:
|
||||
void exportCurrentScene(Scene *sce, const char* filename);
|
||||
void exportCurrentScene(Scene *sce, const char* filename, bool selected);
|
||||
void exportScenes(const char* filename);
|
||||
};
|
||||
|
||||
|
@ -78,12 +78,12 @@ bool EffectsExporter::hasEffects(Scene *sce)
|
||||
return false;
|
||||
}
|
||||
|
||||
void EffectsExporter::exportEffects(Scene *sce)
|
||||
void EffectsExporter::exportEffects(Scene *sce, bool export_selected)
|
||||
{
|
||||
if(hasEffects(sce)) {
|
||||
openLibrary();
|
||||
MaterialFunctor mf;
|
||||
mf.forEachMaterialInScene<EffectsExporter>(sce, *this);
|
||||
mf.forEachMaterialInScene<EffectsExporter>(sce, *this, export_selected);
|
||||
|
||||
closeLibrary();
|
||||
}
|
||||
|
@ -47,7 +47,7 @@ class EffectsExporter: COLLADASW::LibraryEffects
|
||||
{
|
||||
public:
|
||||
EffectsExporter(COLLADASW::StreamWriter *sw);
|
||||
void exportEffects(Scene *sce);
|
||||
void exportEffects(Scene *sce, bool export_selected);
|
||||
|
||||
void operator()(Material *ma, Object *ob);
|
||||
|
||||
|
@ -47,13 +47,13 @@
|
||||
GeometryExporter::GeometryExporter(COLLADASW::StreamWriter *sw) : COLLADASW::LibraryGeometries(sw) {}
|
||||
|
||||
|
||||
void GeometryExporter::exportGeom(Scene *sce)
|
||||
void GeometryExporter::exportGeom(Scene *sce, bool export_selected)
|
||||
{
|
||||
openLibrary();
|
||||
|
||||
mScene = sce;
|
||||
GeometryFunctor gf;
|
||||
gf.forEachMeshObjectInScene<GeometryExporter>(sce, *this);
|
||||
gf.forEachMeshObjectInScene<GeometryExporter>(sce, *this, export_selected);
|
||||
|
||||
closeLibrary();
|
||||
}
|
||||
|
@ -60,7 +60,7 @@ class GeometryExporter : COLLADASW::LibraryGeometries
|
||||
public:
|
||||
GeometryExporter(COLLADASW::StreamWriter *sw);
|
||||
|
||||
void exportGeom(Scene *sce);
|
||||
void exportGeom(Scene *sce, bool export_selected);
|
||||
|
||||
void operator()(Object *ob);
|
||||
|
||||
@ -102,14 +102,15 @@ struct GeometryFunctor {
|
||||
// f should have
|
||||
// void operator()(Object* ob)
|
||||
template<class Functor>
|
||||
void forEachMeshObjectInScene(Scene *sce, Functor &f)
|
||||
void forEachMeshObjectInScene(Scene *sce, Functor &f, bool export_selected)
|
||||
{
|
||||
|
||||
Base *base= (Base*) sce->base.first;
|
||||
while(base) {
|
||||
Object *ob = base->object;
|
||||
|
||||
if (ob->type == OB_MESH && ob->data) {
|
||||
if (ob->type == OB_MESH && ob->data
|
||||
&& !(export_selected && !(ob->flag && SELECT))) {
|
||||
f(ob);
|
||||
}
|
||||
base= base->next;
|
||||
|
@ -71,12 +71,12 @@ bool ImagesExporter::hasImages(Scene *sce)
|
||||
return false;
|
||||
}
|
||||
|
||||
void ImagesExporter::exportImages(Scene *sce)
|
||||
void ImagesExporter::exportImages(Scene *sce, bool export_selected)
|
||||
{
|
||||
if(hasImages(sce)) {
|
||||
openLibrary();
|
||||
MaterialFunctor mf;
|
||||
mf.forEachMaterialInScene<ImagesExporter>(sce, *this);
|
||||
mf.forEachMaterialInScene<ImagesExporter>(sce, *this, export_selected);
|
||||
|
||||
closeLibrary();
|
||||
}
|
||||
|
@ -47,7 +47,7 @@ class ImagesExporter: COLLADASW::LibraryImages
|
||||
public:
|
||||
ImagesExporter(COLLADASW::StreamWriter *sw, const char* filename);
|
||||
|
||||
void exportImages(Scene *sce);
|
||||
void exportImages(Scene *sce, bool export_selected);
|
||||
void operator()(Material *ma, Object *ob);
|
||||
private:
|
||||
bool hasImages(Scene *sce);
|
||||
|
@ -38,13 +38,14 @@
|
||||
#include "collada_internal.h"
|
||||
|
||||
template<class Functor>
|
||||
void forEachLampObjectInScene(Scene *sce, Functor &f)
|
||||
void forEachLampObjectInScene(Scene *sce, Functor &f, bool export_selected)
|
||||
{
|
||||
Base *base= (Base*) sce->base.first;
|
||||
while(base) {
|
||||
Object *ob = base->object;
|
||||
|
||||
if (ob->type == OB_LAMP && ob->data) {
|
||||
if (ob->type == OB_LAMP && ob->data
|
||||
&& !(export_selected && !(ob->flag & SELECT))) {
|
||||
f(ob);
|
||||
}
|
||||
base= base->next;
|
||||
@ -53,11 +54,11 @@ void forEachLampObjectInScene(Scene *sce, Functor &f)
|
||||
|
||||
LightsExporter::LightsExporter(COLLADASW::StreamWriter *sw): COLLADASW::LibraryLights(sw){}
|
||||
|
||||
void LightsExporter::exportLights(Scene *sce)
|
||||
void LightsExporter::exportLights(Scene *sce, bool export_selected)
|
||||
{
|
||||
openLibrary();
|
||||
|
||||
forEachLampObjectInScene(sce, *this);
|
||||
forEachLampObjectInScene(sce, *this, export_selected);
|
||||
|
||||
closeLibrary();
|
||||
}
|
||||
|
@ -41,7 +41,7 @@ class LightsExporter: COLLADASW::LibraryLights
|
||||
{
|
||||
public:
|
||||
LightsExporter(COLLADASW::StreamWriter *sw);
|
||||
void exportLights(Scene *sce);
|
||||
void exportLights(Scene *sce, bool export_selected);
|
||||
void operator()(Object *ob);
|
||||
private:
|
||||
bool exportBlenderProfile(COLLADASW::Light &cla, Lamp *la);
|
||||
|
@ -35,12 +35,12 @@
|
||||
|
||||
MaterialsExporter::MaterialsExporter(COLLADASW::StreamWriter *sw): COLLADASW::LibraryMaterials(sw){}
|
||||
|
||||
void MaterialsExporter::exportMaterials(Scene *sce)
|
||||
void MaterialsExporter::exportMaterials(Scene *sce, bool export_selected)
|
||||
{
|
||||
openLibrary();
|
||||
|
||||
MaterialFunctor mf;
|
||||
mf.forEachMaterialInScene<MaterialsExporter>(sce, *this);
|
||||
mf.forEachMaterialInScene<MaterialsExporter>(sce, *this, export_selected);
|
||||
|
||||
closeLibrary();
|
||||
}
|
||||
|
@ -49,7 +49,7 @@ class MaterialsExporter: COLLADASW::LibraryMaterials
|
||||
{
|
||||
public:
|
||||
MaterialsExporter(COLLADASW::StreamWriter *sw);
|
||||
void exportMaterials(Scene *sce);
|
||||
void exportMaterials(Scene *sce, bool export_selected);
|
||||
void operator()(Material *ma, Object *ob);
|
||||
};
|
||||
|
||||
@ -86,11 +86,11 @@ struct MaterialFunctor {
|
||||
// f should have
|
||||
// void operator()(Material* ma)
|
||||
template<class Functor>
|
||||
void forEachMaterialInScene(Scene *sce, Functor &f)
|
||||
void forEachMaterialInScene(Scene *sce, Functor &f, bool export_selected)
|
||||
{
|
||||
ForEachMaterialFunctor<Functor> matfunc(&f);
|
||||
GeometryFunctor gf;
|
||||
gf.forEachMeshObjectInScene<ForEachMaterialFunctor<Functor> >(sce, matfunc);
|
||||
gf.forEachMeshObjectInScene<ForEachMaterialFunctor<Functor> >(sce, matfunc, export_selected);
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -144,15 +144,18 @@ void WVDataWrapper::print()
|
||||
}
|
||||
#endif
|
||||
|
||||
void UVDataWrapper::getUV(int uv_index[2], float *uv)
|
||||
void UVDataWrapper::getUV(int uv_index, float *uv)
|
||||
{
|
||||
int stride = mVData->getStride(0);
|
||||
if(stride==0) stride = 2;
|
||||
|
||||
switch(mVData->getType()) {
|
||||
case COLLADAFW::MeshVertexData::DATA_TYPE_FLOAT:
|
||||
{
|
||||
COLLADAFW::ArrayPrimitiveType<float>* values = mVData->getFloatValues();
|
||||
if (values->empty()) return;
|
||||
uv[0] = (*values)[uv_index[0]];
|
||||
uv[1] = (*values)[uv_index[1]];
|
||||
uv[0] = (*values)[uv_index*stride];
|
||||
uv[1] = (*values)[uv_index*stride + 1];
|
||||
|
||||
}
|
||||
break;
|
||||
@ -160,8 +163,8 @@ void UVDataWrapper::getUV(int uv_index[2], float *uv)
|
||||
{
|
||||
COLLADAFW::ArrayPrimitiveType<double>* values = mVData->getDoubleValues();
|
||||
if (values->empty()) return;
|
||||
uv[0] = (float)(*values)[uv_index[0]];
|
||||
uv[1] = (float)(*values)[uv_index[1]];
|
||||
uv[0] = (float)(*values)[uv_index*stride];
|
||||
uv[1] = (float)(*values)[uv_index*stride + 1];
|
||||
|
||||
}
|
||||
break;
|
||||
@ -197,54 +200,36 @@ void MeshImporter::rotate_face_indices(MFace *mface) {
|
||||
void MeshImporter::set_face_uv(MTFace *mtface, UVDataWrapper &uvs,
|
||||
COLLADAFW::IndexList& index_list, unsigned int *tris_indices)
|
||||
{
|
||||
int uv_indices[4][2];
|
||||
|
||||
// per face vertex indices, this means for quad we have 4 indices, not 8
|
||||
COLLADAFW::UIntValuesArray& indices = index_list.getIndices();
|
||||
|
||||
// make indices into FloatOrDoubleArray
|
||||
for (int i = 0; i < 3; i++) {
|
||||
int uv_index = indices[tris_indices[i]];
|
||||
uv_indices[i][0] = uv_index * 2;
|
||||
uv_indices[i][1] = uv_index * 2 + 1;
|
||||
}
|
||||
|
||||
uvs.getUV(uv_indices[0], mtface->uv[0]);
|
||||
uvs.getUV(uv_indices[1], mtface->uv[1]);
|
||||
uvs.getUV(uv_indices[2], mtface->uv[2]);
|
||||
uvs.getUV(indices[tris_indices[0]], mtface->uv[0]);
|
||||
uvs.getUV(indices[tris_indices[1]], mtface->uv[1]);
|
||||
uvs.getUV(indices[tris_indices[2]], mtface->uv[2]);
|
||||
}
|
||||
|
||||
void MeshImporter::set_face_uv(MTFace *mtface, UVDataWrapper &uvs,
|
||||
COLLADAFW::IndexList& index_list, int index, bool quad)
|
||||
{
|
||||
int uv_indices[4][2];
|
||||
|
||||
// per face vertex indices, this means for quad we have 4 indices, not 8
|
||||
COLLADAFW::UIntValuesArray& indices = index_list.getIndices();
|
||||
|
||||
// make indices into FloatOrDoubleArray
|
||||
for (int i = 0; i < (quad ? 4 : 3); i++) {
|
||||
int uv_index = indices[index + i];
|
||||
uv_indices[i][0] = uv_index * 2;
|
||||
uv_indices[i][1] = uv_index * 2 + 1;
|
||||
}
|
||||
uvs.getUV(indices[index + 0], mtface->uv[0]);
|
||||
uvs.getUV(indices[index + 1], mtface->uv[1]);
|
||||
uvs.getUV(indices[index + 2], mtface->uv[2]);
|
||||
|
||||
uvs.getUV(uv_indices[0], mtface->uv[0]);
|
||||
uvs.getUV(uv_indices[1], mtface->uv[1]);
|
||||
uvs.getUV(uv_indices[2], mtface->uv[2]);
|
||||
|
||||
if (quad) uvs.getUV(uv_indices[3], mtface->uv[3]);
|
||||
if (quad) uvs.getUV(indices[index + 3], mtface->uv[3]);
|
||||
|
||||
#ifdef COLLADA_DEBUG
|
||||
/*if (quad) {
|
||||
fprintf(stderr, "face uv:\n"
|
||||
"((%d, %d), (%d, %d), (%d, %d), (%d, %d))\n"
|
||||
"((%d, %d, %d, %d))\n"
|
||||
"((%.1f, %.1f), (%.1f, %.1f), (%.1f, %.1f), (%.1f, %.1f))\n",
|
||||
|
||||
uv_indices[0][0], uv_indices[0][1],
|
||||
uv_indices[1][0], uv_indices[1][1],
|
||||
uv_indices[2][0], uv_indices[2][1],
|
||||
uv_indices[3][0], uv_indices[3][1],
|
||||
indices[index + 0],
|
||||
indices[index + 1],
|
||||
indices[index + 2],
|
||||
indices[index + 3],
|
||||
|
||||
mtface->uv[0][0], mtface->uv[0][1],
|
||||
mtface->uv[1][0], mtface->uv[1][1],
|
||||
@ -253,12 +238,12 @@ void MeshImporter::set_face_uv(MTFace *mtface, UVDataWrapper &uvs,
|
||||
}
|
||||
else {
|
||||
fprintf(stderr, "face uv:\n"
|
||||
"((%d, %d), (%d, %d), (%d, %d))\n"
|
||||
"((%d, %d, %d))\n"
|
||||
"((%.1f, %.1f), (%.1f, %.1f), (%.1f, %.1f))\n",
|
||||
|
||||
uv_indices[0][0], uv_indices[0][1],
|
||||
uv_indices[1][0], uv_indices[1][1],
|
||||
uv_indices[2][0], uv_indices[2][1],
|
||||
indices[index + 0],
|
||||
indices[index + 1],
|
||||
indices[index + 2],
|
||||
|
||||
mtface->uv[0][0], mtface->uv[0][1],
|
||||
mtface->uv[1][0], mtface->uv[1][1],
|
||||
|
@ -69,7 +69,7 @@ public:
|
||||
void print();
|
||||
#endif
|
||||
|
||||
void getUV(int uv_index[2], float *uv);
|
||||
void getUV(int uv_index, float *uv);
|
||||
};
|
||||
|
||||
class MeshImporter : public MeshImporterBase
|
||||
|
@ -51,7 +51,7 @@ extern "C"
|
||||
return 1;
|
||||
}
|
||||
|
||||
int collada_export(Scene *sce, const char *filepath)
|
||||
int collada_export(Scene *sce, const char *filepath, int selected)
|
||||
{
|
||||
DocumentExporter exp;
|
||||
|
||||
@ -64,7 +64,7 @@ extern "C"
|
||||
}
|
||||
/* end! */
|
||||
|
||||
exp.exportCurrentScene(sce, filepath);
|
||||
exp.exportCurrentScene(sce, filepath, selected);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
@ -39,7 +39,7 @@ extern "C" {
|
||||
* both return 1 on success, 0 on error
|
||||
*/
|
||||
int collada_import(bContext *C, const char *filepath);
|
||||
int collada_export(Scene *sce, const char *filepath);
|
||||
int collada_export(Scene *sce, const char *filepath, int selected);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
@ -265,7 +265,7 @@ std::string get_light_id(Object *ob)
|
||||
|
||||
std::string get_joint_id(Bone *bone, Object *ob_arm)
|
||||
{
|
||||
return translate_id(bone->name);
|
||||
return translate_id(/*id_name(ob_arm) + "_" +*/ bone->name);
|
||||
}
|
||||
|
||||
std::string get_camera_id(Object *ob)
|
||||
|
@ -50,6 +50,7 @@
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_report.h"
|
||||
#include "BKE_scene.h"
|
||||
#include "BKE_screen.h"
|
||||
|
||||
#include "WM_api.h"
|
||||
#include "WM_types.h"
|
||||
@ -1416,7 +1417,9 @@ static void MARKER_OT_make_links_scene(wmOperatorType *ot)
|
||||
|
||||
static int ed_marker_camera_bind_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
{
|
||||
bScreen *sc= CTX_wm_screen(C);
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Object *ob = CTX_data_active_object(C);
|
||||
ListBase *markers= ED_context_get_markers(C);
|
||||
TimeMarker *marker;
|
||||
|
||||
@ -1424,10 +1427,15 @@ static int ed_marker_camera_bind_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
if(marker == NULL)
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
marker->camera= scene->camera;
|
||||
marker->camera= ob;
|
||||
|
||||
/* camera may have changes */
|
||||
scene_camera_switch_update(scene);
|
||||
BKE_screen_view3d_scene_sync(sc);
|
||||
|
||||
WM_event_add_notifier(C, NC_SCENE|ND_MARKERS, NULL);
|
||||
WM_event_add_notifier(C, NC_ANIMATION|ND_MARKERS, NULL);
|
||||
WM_event_add_notifier(C, NC_SCENE|NA_EDITED, scene); /* so we get view3d redraws */
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
@ -3535,6 +3535,11 @@ static int convertspline(short type, Nurb *nu)
|
||||
return 0;
|
||||
}
|
||||
|
||||
void ED_nurb_set_spline_type(Nurb *nu, int type)
|
||||
{
|
||||
convertspline(type, nu);
|
||||
}
|
||||
|
||||
static int set_spline_type_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Object *obedit= CTX_data_edit_object(C);
|
||||
|
@ -71,6 +71,7 @@ int mouse_nurb (struct bContext *C, const int mval[2], int extend);
|
||||
struct Nurb *add_nurbs_primitive(struct bContext *C, float mat[4][4], int type, int newob);
|
||||
|
||||
int isNurbsel (struct Nurb *nu);
|
||||
void ED_nurb_set_spline_type(struct Nurb *nu, int type);
|
||||
|
||||
int join_curve_exec (struct bContext *C, struct wmOperator *op);
|
||||
|
||||
|
@ -74,8 +74,8 @@
|
||||
#define MENU_ITEM_HEIGHT 20
|
||||
#define MENU_SEP_HEIGHT 6
|
||||
|
||||
#define PRECISION_FLOAT_MAX 7
|
||||
#define PRECISION_FLOAT_MAX_POW 10000000 /* pow(10, PRECISION_FLOAT_MAX) */
|
||||
#define PRECISION_FLOAT_MAX 6
|
||||
#define PRECISION_FLOAT_MAX_POW 1000000 /* pow(10, PRECISION_FLOAT_MAX) */
|
||||
|
||||
/* avoid unneeded calls to ui_get_but_val */
|
||||
#define UI_BUT_VALUE_UNSET DBL_MAX
|
||||
|
@ -1895,7 +1895,15 @@ static void ui_do_but_textedit(bContext *C, uiBlock *block, uiBut *but, uiHandle
|
||||
}
|
||||
|
||||
if(event->ascii && (retval == WM_UI_HANDLER_CONTINUE)) {
|
||||
changed= ui_textedit_type_ascii(but, data, event->ascii);
|
||||
char ascii = event->ascii;
|
||||
|
||||
/* exception that's useful for number buttons, some keyboard
|
||||
numpads have a comma instead of a period */
|
||||
if(ELEM3(but->type, NUM, NUMABS, NUMSLI))
|
||||
if(event->type == PADPERIOD && ascii == ',')
|
||||
ascii = '.';
|
||||
|
||||
changed= ui_textedit_type_ascii(but, data, ascii);
|
||||
retval= WM_UI_HANDLER_BREAK;
|
||||
|
||||
}
|
||||
|
@ -33,6 +33,7 @@
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
#include "DNA_key_types.h"
|
||||
#include "DNA_scene_types.h"
|
||||
#include "DNA_userdef_types.h"
|
||||
|
||||
@ -2104,6 +2105,7 @@ static void list_item_row(bContext *C, uiLayout *layout, PointerRNA *ptr, Pointe
|
||||
}
|
||||
else if(itemptr->type == &RNA_ShapeKey) {
|
||||
Object *ob= (Object*)activeptr->data;
|
||||
Key *key= (Key*)itemptr->data;
|
||||
|
||||
split= uiLayoutSplit(sub, 0.75f, 0);
|
||||
|
||||
@ -2111,7 +2113,7 @@ static void list_item_row(bContext *C, uiLayout *layout, PointerRNA *ptr, Pointe
|
||||
|
||||
uiBlockSetEmboss(block, UI_EMBOSSN);
|
||||
row= uiLayoutRow(split, 1);
|
||||
if(i == 0) uiItemL(row, "", ICON_NONE);
|
||||
if(i == 0 || (key->type != KEY_RELATIVE)) uiItemL(row, "", ICON_NONE);
|
||||
else uiItemR(row, itemptr, "value", 0, "", ICON_NONE);
|
||||
|
||||
if(ob->mode == OB_MODE_EDIT && !((ob->shapeflag & OB_SHAPE_EDIT_MODE) && ob->type == OB_MESH))
|
||||
|
@ -608,9 +608,12 @@ static float seg_intersect(EditEdge *e, CutCurve *c, int len, char mode, struct
|
||||
return(perc);
|
||||
}
|
||||
|
||||
|
||||
/* for multicut */
|
||||
#define MAX_CUTS 256
|
||||
|
||||
/* for amount of edges */
|
||||
#define MAX_CUT_EDGES 1024
|
||||
|
||||
static int knife_cut_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Object *obedit= CTX_data_edit_object(C);
|
||||
@ -618,7 +621,7 @@ static int knife_cut_exec(bContext *C, wmOperator *op)
|
||||
ARegion *ar= CTX_wm_region(C);
|
||||
EditEdge *eed;
|
||||
EditVert *eve;
|
||||
CutCurve curve[MAX_CUTS];
|
||||
CutCurve curve[MAX_CUT_EDGES];
|
||||
struct GHash *gh;
|
||||
float isect=0.0;
|
||||
float *scr, co[4];
|
||||
@ -642,7 +645,7 @@ static int knife_cut_exec(bContext *C, wmOperator *op)
|
||||
|
||||
RNA_float_get_array(&itemptr, "loc", (float *)&curve[len]);
|
||||
len++;
|
||||
if(len>= MAX_CUTS) break;
|
||||
if(len>= MAX_CUT_EDGES) break;
|
||||
}
|
||||
RNA_END;
|
||||
|
||||
|
@ -401,6 +401,8 @@ static int modifier_apply_shape(ReportList *reports, Scene *scene, Object *ob, M
|
||||
{
|
||||
ModifierTypeInfo *mti= modifierType_getInfo(md->type);
|
||||
|
||||
md->scene= scene;
|
||||
|
||||
if (mti->isDisabled && mti->isDisabled(md, 0)) {
|
||||
BKE_report(reports, RPT_ERROR, "Modifier is disabled, skipping apply");
|
||||
return 0;
|
||||
@ -449,6 +451,8 @@ static int modifier_apply_obdata(ReportList *reports, Scene *scene, Object *ob,
|
||||
{
|
||||
ModifierTypeInfo *mti= modifierType_getInfo(md->type);
|
||||
|
||||
md->scene= scene;
|
||||
|
||||
if (mti->isDisabled && mti->isDisabled(md, 0)) {
|
||||
BKE_report(reports, RPT_ERROR, "Modifier is disabled, skipping apply");
|
||||
return 0;
|
||||
|
@ -1660,6 +1660,7 @@ void ED_object_single_users(Main *bmain, Scene *scene, int full)
|
||||
|
||||
if(full) {
|
||||
single_obdata_users(bmain, scene, 0);
|
||||
single_object_action_users(scene, 0);
|
||||
single_mat_users_expand(bmain);
|
||||
single_tex_users_expand(bmain);
|
||||
}
|
||||
|
@ -827,6 +827,8 @@ static void PE_mirror_particle(Object *ob, DerivedMesh *dm, ParticleSystem *psys
|
||||
|
||||
if(key->flag & PEK_TAG)
|
||||
mkey->flag |= PEK_TAG;
|
||||
|
||||
mkey->length = key->length;
|
||||
}
|
||||
|
||||
if(point->flag & PEP_TAG)
|
||||
|
@ -438,8 +438,6 @@ static int screen_opengl_render_anim_step(bContext *C, wmOperator *op)
|
||||
ibuf= BKE_image_acquire_ibuf(oglrender->ima, &oglrender->iuser, &lock);
|
||||
|
||||
if(ibuf) {
|
||||
short ibuf_free= FALSE;
|
||||
|
||||
/* color -> greyscale */
|
||||
/* editing directly would alter the render view */
|
||||
if(scene->r.planes == 8) {
|
||||
@ -447,8 +445,15 @@ static int screen_opengl_render_anim_step(bContext *C, wmOperator *op)
|
||||
IMB_color_to_bw(ibuf_bw);
|
||||
// IMB_freeImBuf(ibuf); /* owned by the image */
|
||||
ibuf= ibuf_bw;
|
||||
|
||||
ibuf_free= TRUE;
|
||||
}
|
||||
else {
|
||||
/* this is lightweight & doesnt re-alloc the buffers, only do this
|
||||
* to save the correct bit depth since the image is always RGBA */
|
||||
ImBuf *ibuf_cpy= IMB_allocImBuf(ibuf->x, ibuf->y, scene->r.planes, 0);
|
||||
ibuf_cpy->rect= ibuf->rect;
|
||||
ibuf_cpy->rect_float= ibuf->rect_float;
|
||||
ibuf_cpy->zbuf_float= ibuf->zbuf_float;
|
||||
ibuf= ibuf_cpy;
|
||||
}
|
||||
|
||||
if(BKE_imtype_is_movie(scene->r.imtype)) {
|
||||
@ -472,10 +477,9 @@ static int screen_opengl_render_anim_step(bContext *C, wmOperator *op)
|
||||
}
|
||||
}
|
||||
|
||||
if(ibuf_free) {
|
||||
/* imbuf knows which rects are not part of ibuf */
|
||||
IMB_freeImBuf(ibuf);
|
||||
}
|
||||
}
|
||||
|
||||
BKE_image_release_ibuf(oglrender->ima, lock);
|
||||
|
||||
|
@ -423,6 +423,7 @@ static void node_shader_buts_dynamic(uiLayout *layout, bContext *C, PointerRNA *
|
||||
/* only once called */
|
||||
static void node_shader_set_butfunc(bNodeType *ntype)
|
||||
{
|
||||
ntype->uifuncbut = NULL;
|
||||
switch(ntype->type) {
|
||||
/* case NODE_GROUP: note, typeinfo for group is generated... see "XXX ugly hack" */
|
||||
|
||||
@ -472,6 +473,7 @@ static void node_shader_set_butfunc(bNodeType *ntype)
|
||||
default:
|
||||
ntype->uifunc= NULL;
|
||||
}
|
||||
if (ntype->uifuncbut == NULL) ntype->uifuncbut = ntype->uifunc;
|
||||
}
|
||||
|
||||
/* ****************** BUTTON CALLBACKS FOR COMPOSITE NODES ***************** */
|
||||
@ -1036,6 +1038,32 @@ static void node_composit_buts_colorbalance(uiLayout *layout, bContext *UNUSED(C
|
||||
}
|
||||
|
||||
}
|
||||
static void node_composit_buts_colorbalance_but(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
|
||||
{
|
||||
uiItemR(layout, ptr, "correction_method", 0, NULL, ICON_NONE);
|
||||
|
||||
if (RNA_enum_get(ptr, "correction_method")== 0) {
|
||||
|
||||
uiTemplateColorWheel(layout, ptr, "lift", 1, 1, 0, 1);
|
||||
uiItemR(layout, ptr, "lift", 0, NULL, ICON_NONE);
|
||||
|
||||
uiTemplateColorWheel(layout, ptr, "gamma", 1, 1, 1, 1);
|
||||
uiItemR(layout, ptr, "gamma", 0, NULL, ICON_NONE);
|
||||
|
||||
uiTemplateColorWheel(layout, ptr, "gain", 1, 1, 1, 1);
|
||||
uiItemR(layout, ptr, "gain", 0, NULL, ICON_NONE);
|
||||
} else {
|
||||
uiTemplateColorWheel(layout, ptr, "offset", 1, 1, 0, 1);
|
||||
uiItemR(layout, ptr, "offset", 0, NULL, ICON_NONE);
|
||||
|
||||
uiTemplateColorWheel(layout, ptr, "power", 1, 1, 0, 1);
|
||||
uiItemR(layout, ptr, "power", 0, NULL, ICON_NONE);
|
||||
|
||||
uiTemplateColorWheel(layout, ptr, "slope", 1, 1, 0, 1);
|
||||
uiItemR(layout, ptr, "slope", 0, NULL, ICON_NONE);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void node_composit_buts_huecorrect(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
|
||||
{
|
||||
@ -1050,6 +1078,7 @@ static void node_composit_buts_ycc(uiLayout *layout, bContext *UNUSED(C), Pointe
|
||||
/* only once called */
|
||||
static void node_composit_set_butfunc(bNodeType *ntype)
|
||||
{
|
||||
ntype->uifuncbut = NULL;
|
||||
switch(ntype->type) {
|
||||
/* case NODE_GROUP: note, typeinfo for group is generated... see "XXX ugly hack" */
|
||||
|
||||
@ -1184,6 +1213,7 @@ static void node_composit_set_butfunc(bNodeType *ntype)
|
||||
break;
|
||||
case CMP_NODE_COLORBALANCE:
|
||||
ntype->uifunc=node_composit_buts_colorbalance;
|
||||
ntype->uifuncbut=node_composit_buts_colorbalance_but;
|
||||
break;
|
||||
case CMP_NODE_HUECORRECT:
|
||||
ntype->uifunc=node_composit_buts_huecorrect;
|
||||
@ -1198,6 +1228,8 @@ static void node_composit_set_butfunc(bNodeType *ntype)
|
||||
default:
|
||||
ntype->uifunc= NULL;
|
||||
}
|
||||
if (ntype->uifuncbut == NULL) ntype->uifuncbut = ntype->uifunc;
|
||||
|
||||
}
|
||||
|
||||
/* ****************** BUTTON CALLBACKS FOR TEXTURE NODES ***************** */
|
||||
@ -1308,6 +1340,7 @@ static void node_texture_buts_output(uiLayout *layout, bContext *UNUSED(C), Poin
|
||||
/* only once called */
|
||||
static void node_texture_set_butfunc(bNodeType *ntype)
|
||||
{
|
||||
ntype->uifuncbut = NULL;
|
||||
if( ntype->type >= TEX_NODE_PROC && ntype->type < TEX_NODE_PROC_MAX ) {
|
||||
ntype->uifunc = node_texture_buts_proc;
|
||||
}
|
||||
@ -1352,6 +1385,7 @@ static void node_texture_set_butfunc(bNodeType *ntype)
|
||||
default:
|
||||
ntype->uifunc= NULL;
|
||||
}
|
||||
if (ntype->uifuncbut == NULL) ntype->uifuncbut = ntype->uifunc;
|
||||
}
|
||||
|
||||
/* ******* init draw callbacks for all tree types, only called in usiblender.c, once ************* */
|
||||
|
@ -118,8 +118,8 @@ static void active_node_panel(const bContext *C, Panel *pa)
|
||||
uiItemS(layout);
|
||||
|
||||
/* draw this node's settings */
|
||||
if (node->typeinfo && node->typeinfo->uifunc)
|
||||
node->typeinfo->uifunc(layout, (bContext *)C, &ptr);
|
||||
if (node->typeinfo && node->typeinfo->uifuncbut)
|
||||
node->typeinfo->uifuncbut(layout, (bContext *)C, &ptr);
|
||||
}
|
||||
|
||||
/* ******************* node buttons registration ************** */
|
||||
|
@ -480,6 +480,10 @@ static void outliner_add_passes(SpaceOops *soops, TreeElement *tenla, ID *id, Sc
|
||||
te->name= "Index Object";
|
||||
te->directdata= &srl->passflag;
|
||||
|
||||
te= outliner_add_element(soops, &tenla->subtree, id, tenla, TSE_R_PASS, LOG2I(SCE_PASS_INDEXMA));
|
||||
te->name= "Index Material";
|
||||
te->directdata= &srl->passflag;
|
||||
|
||||
te= outliner_add_element(soops, &tenla->subtree, id, tenla, TSE_R_PASS, LOG2I(SCE_PASS_RGBA));
|
||||
te->name= "Color";
|
||||
te->directdata= &srl->passflag;
|
||||
@ -4902,7 +4906,7 @@ static void outliner_draw_tree(bContext *C, uiBlock *block, Scene *scene, ARegio
|
||||
outliner_draw_selection(ar, soops, &soops->tree, &starty);
|
||||
|
||||
// grey hierarchy lines
|
||||
UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.2f);
|
||||
UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.4f);
|
||||
starty= (int)ar->v2d.tot.ymax-UI_UNIT_Y/2-OL_Y_OFFSET;
|
||||
startx= 6;
|
||||
outliner_draw_hierarchy(soops, &soops->tree, startx, &starty);
|
||||
|
@ -643,9 +643,11 @@ static void draw_seq_strip(Scene *scene, ARegion *ar, Sequence *seq, int outline
|
||||
if (G.moving && (seq->flag & SELECT)) {
|
||||
if(seq->flag & SEQ_OVERLAP) {
|
||||
col[0]= 255; col[1]= col[2]= 40;
|
||||
} else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 120);
|
||||
}
|
||||
|
||||
else
|
||||
UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 120+outline_tint);
|
||||
}
|
||||
else
|
||||
UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, outline_tint);
|
||||
|
||||
glColor3ubv((GLubyte *)col);
|
||||
@ -969,7 +971,7 @@ static void draw_seq_strips(const bContext *C, Editing *ed, ARegion *ar)
|
||||
/* loop through strips, checking for those that are visible */
|
||||
for (seq= ed->seqbasep->first; seq; seq= seq->next) {
|
||||
/* boundbox and selection tests for NOT drawing the strip... */
|
||||
if ((seq->flag & SELECT) == sel) continue;
|
||||
if ((seq->flag & SELECT) != sel) continue;
|
||||
else if (seq == last_seq) continue;
|
||||
else if (MIN2(seq->startdisp, seq->start) > v2d->cur.xmax) continue;
|
||||
else if (MAX2(seq->enddisp, seq->start+seq->len) < v2d->cur.xmin) continue;
|
||||
|
@ -124,6 +124,7 @@ typedef struct TransSeq {
|
||||
int startstill, endstill;
|
||||
int startdisp, enddisp;
|
||||
int startofs, endofs;
|
||||
int anim_startofs, anim_endofs;
|
||||
/* int final_left, final_right; */ /* UNUSED */
|
||||
int len;
|
||||
} TransSeq;
|
||||
@ -729,8 +730,10 @@ static Sequence *cut_seq_hard(Scene *scene, Sequence * seq, int cutframe)
|
||||
ts.endstill= seq->endstill;
|
||||
ts.startdisp= seq->startdisp;
|
||||
ts.enddisp= seq->enddisp;
|
||||
ts.startofs= seq->anim_startofs;
|
||||
ts.endofs= seq->anim_endofs;
|
||||
ts.startofs= seq->startofs;
|
||||
ts.endofs= seq->endofs;
|
||||
ts.anim_startofs= seq->anim_startofs;
|
||||
ts.anim_endofs= seq->anim_endofs;
|
||||
ts.len= seq->len;
|
||||
|
||||
/* First Strip! */
|
||||
@ -780,7 +783,7 @@ static Sequence *cut_seq_hard(Scene *scene, Sequence * seq, int cutframe)
|
||||
if ((seqn->startstill) && (cutframe == seqn->start + 1)) {
|
||||
seqn->start = ts.start;
|
||||
seqn->startstill= ts.start- cutframe;
|
||||
seqn->anim_endofs = ts.endofs;
|
||||
seqn->anim_endofs = ts.anim_endofs;
|
||||
seqn->endstill = ts.endstill;
|
||||
}
|
||||
|
||||
@ -789,8 +792,9 @@ static Sequence *cut_seq_hard(Scene *scene, Sequence * seq, int cutframe)
|
||||
seqn->start = cutframe;
|
||||
seqn->startstill = 0;
|
||||
seqn->startofs = 0;
|
||||
seqn->endofs = ts.endofs;
|
||||
seqn->anim_startofs += cutframe - ts.start;
|
||||
seqn->anim_endofs = ts.endofs;
|
||||
seqn->anim_endofs = ts.anim_endofs;
|
||||
seqn->endstill = ts.endstill;
|
||||
}
|
||||
|
||||
@ -825,6 +829,8 @@ static Sequence *cut_seq_soft(Scene *scene, Sequence * seq, int cutframe)
|
||||
ts.enddisp= seq->enddisp;
|
||||
ts.startofs= seq->startofs;
|
||||
ts.endofs= seq->endofs;
|
||||
ts.anim_startofs= seq->anim_startofs;
|
||||
ts.anim_endofs= seq->anim_endofs;
|
||||
ts.len= seq->len;
|
||||
|
||||
/* First Strip! */
|
||||
@ -1778,19 +1784,21 @@ static int sequencer_separate_images_exec(bContext *C, wmOperator *op)
|
||||
/* new seq */
|
||||
se = give_stripelem(seq, cfra);
|
||||
|
||||
seq_new= alloc_sequence(ed->seqbasep, start_ofs, seq->machine);
|
||||
seq_new= seq_dupli_recursive(scene, scene, seq, SEQ_DUPE_UNIQUE_NAME);
|
||||
BLI_addtail(&ed->seqbase, seq_new);
|
||||
|
||||
seq_new->start= start_ofs;
|
||||
seq_new->type= SEQ_IMAGE;
|
||||
seq_new->len = 1;
|
||||
seq_new->endstill = step-1;
|
||||
|
||||
/* new strip */
|
||||
seq_new->strip= strip_new= MEM_callocN(sizeof(Strip)*1, "strip");
|
||||
strip_new= seq_new->strip;
|
||||
strip_new->len= 1;
|
||||
strip_new->us= 1;
|
||||
strncpy(strip_new->dir, seq->strip->dir, FILE_MAXDIR-1);
|
||||
|
||||
/* new stripdata */
|
||||
strip_new->stripdata= se_new= MEM_callocN(sizeof(StripElem)*1, "stripelem");
|
||||
se_new= strip_new->stripdata;
|
||||
BLI_strncpy(se_new->name, se->name, sizeof(se_new->name));
|
||||
calc_sequence(scene, seq_new);
|
||||
|
||||
@ -1802,8 +1810,6 @@ static int sequencer_separate_images_exec(bContext *C, wmOperator *op)
|
||||
}
|
||||
|
||||
/* XXX, COPY FCURVES */
|
||||
strncpy(seq_new->name+2, seq->name+2, sizeof(seq->name)-2);
|
||||
seqbase_unique_name_recursive(&scene->ed->seqbase, seq_new);
|
||||
|
||||
cfra++;
|
||||
start_ofs += step;
|
||||
|
@ -197,8 +197,7 @@ static short set_pchan_glColor (short colCode, int boneflag, int constflag)
|
||||
case PCHAN_COLOR_CONSTS:
|
||||
{
|
||||
if ( (bcolor == NULL) || (bcolor->flag & TH_WIRECOLOR_CONSTCOLS) ) {
|
||||
if (constflag & PCHAN_HAS_STRIDE) glColor4ub(0, 0, 200, 80);
|
||||
else if (constflag & PCHAN_HAS_TARGET) glColor4ub(255, 150, 0, 80);
|
||||
if (constflag & PCHAN_HAS_TARGET) glColor4ub(255, 150, 0, 80);
|
||||
else if (constflag & PCHAN_HAS_IK) glColor4ub(255, 255, 0, 80);
|
||||
else if (constflag & PCHAN_HAS_SPLINEIK) glColor4ub(200, 255, 0, 80);
|
||||
else if (constflag & PCHAN_HAS_CONST) glColor4ub(0, 255, 120, 80);
|
||||
@ -269,8 +268,7 @@ static short set_pchan_glColor (short colCode, int boneflag, int constflag)
|
||||
{
|
||||
/* inner part in background color or constraint */
|
||||
if ( (constflag) && ((bcolor==NULL) || (bcolor->flag & TH_WIRECOLOR_CONSTCOLS)) ) {
|
||||
if (constflag & PCHAN_HAS_STRIDE) glColor3ub(0, 0, 200);
|
||||
else if (constflag & PCHAN_HAS_TARGET) glColor3ub(255, 150, 0);
|
||||
if (constflag & PCHAN_HAS_TARGET) glColor3ub(255, 150, 0);
|
||||
else if (constflag & PCHAN_HAS_IK) glColor3ub(255, 255, 0);
|
||||
else if (constflag & PCHAN_HAS_SPLINEIK) glColor3ub(200, 255, 0);
|
||||
else if (constflag & PCHAN_HAS_CONST) glColor3ub(0, 255, 120);
|
||||
@ -1865,8 +1863,6 @@ static void draw_pose_bones(Scene *scene, View3D *v3d, ARegion *ar, Base *base,
|
||||
constflag= pchan->constflag;
|
||||
if (pchan->flag & (POSE_ROT|POSE_LOC|POSE_SIZE))
|
||||
constflag |= PCHAN_HAS_ACTION;
|
||||
if (pchan->flag & POSE_STRIDE)
|
||||
constflag |= PCHAN_HAS_STRIDE;
|
||||
|
||||
/* set color-set to use */
|
||||
set_pchan_colorset(ob, pchan);
|
||||
|
@ -5559,7 +5559,7 @@ static void doAnimEdit_SnapFrame(TransInfo *t, TransData *td, TransData2D *td2d,
|
||||
void initTimeTranslate(TransInfo *t)
|
||||
{
|
||||
/* this tool is only really available in the Action Editor... */
|
||||
if (t->spacetype != SPACE_ACTION) {
|
||||
if (!ELEM(t->spacetype, SPACE_ACTION, SPACE_SEQ)) {
|
||||
t->state = TRANS_CANCEL;
|
||||
}
|
||||
|
||||
|
@ -694,7 +694,7 @@ int count_set_pose_transflags(int *out_mode, short around, Object *ob)
|
||||
for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
|
||||
bone = pchan->bone;
|
||||
if (PBONE_VISIBLE(arm, bone)) {
|
||||
if ((bone->flag & BONE_SELECTED) && !(ob->proxy && pchan->bone->layer & arm->layer_protected))
|
||||
if ((bone->flag & BONE_SELECTED))
|
||||
bone->flag |= BONE_TRANSFORM;
|
||||
else
|
||||
bone->flag &= ~BONE_TRANSFORM;
|
||||
|
@ -278,6 +278,7 @@ int calc_manipulator_stats(const bContext *C)
|
||||
ARegion *ar= CTX_wm_region(C);
|
||||
Scene *scene= CTX_data_scene(C);
|
||||
Object *obedit= CTX_data_edit_object(C);
|
||||
ToolSettings *ts = CTX_data_tool_settings(C);
|
||||
View3D *v3d= sa->spacedata.first;
|
||||
RegionView3D *rv3d= ar->regiondata;
|
||||
Base *base;
|
||||
@ -309,7 +310,10 @@ int calc_manipulator_stats(const bContext *C)
|
||||
calc_tw_center(scene, vec);
|
||||
totsel= 1;
|
||||
} else {
|
||||
/* do vertices for center, and if still no normal found, use vertex normals */
|
||||
/* do vertices/edges/faces for center depending on selection
|
||||
mode. note we can't use just vertex selection flag because
|
||||
it is not flush down on changes */
|
||||
if(ts->selectmode & SCE_SELECT_VERTEX) {
|
||||
for(eve= em->verts.first; eve; eve= eve->next) {
|
||||
if(eve->f & SELECT) {
|
||||
totsel++;
|
||||
@ -317,6 +321,55 @@ int calc_manipulator_stats(const bContext *C)
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(ts->selectmode & SCE_SELECT_EDGE) {
|
||||
EditEdge *eed;
|
||||
|
||||
for(eve= em->verts.first; eve; eve= eve->next) eve->f1= 0;
|
||||
for(eed= em->edges.first; eed; eed= eed->next) {
|
||||
if(eed->h==0 && (eed->f & SELECT)) {
|
||||
if(!eed->v1->f1) {
|
||||
eed->v1->f1= 1;
|
||||
totsel++;
|
||||
calc_tw_center(scene, eed->v1->co);
|
||||
}
|
||||
if(!eed->v2->f1) {
|
||||
eed->v2->f1= 1;
|
||||
totsel++;
|
||||
calc_tw_center(scene, eed->v2->co);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
EditFace *efa;
|
||||
|
||||
for(eve= em->verts.first; eve; eve= eve->next) eve->f1= 0;
|
||||
for(efa= em->faces.first; efa; efa= efa->next) {
|
||||
if(efa->h==0 && (efa->f & SELECT)) {
|
||||
if(!efa->v1->f1) {
|
||||
efa->v1->f1= 1;
|
||||
totsel++;
|
||||
calc_tw_center(scene, efa->v1->co);
|
||||
}
|
||||
if(!efa->v2->f1) {
|
||||
efa->v2->f1= 1;
|
||||
totsel++;
|
||||
calc_tw_center(scene, efa->v2->co);
|
||||
}
|
||||
if(!efa->v3->f1) {
|
||||
efa->v3->f1= 1;
|
||||
totsel++;
|
||||
calc_tw_center(scene, efa->v3->co);
|
||||
}
|
||||
if(efa->v4 && !efa->v4->f1) {
|
||||
efa->v4->f1= 1;
|
||||
totsel++;
|
||||
calc_tw_center(scene, efa->v4->co);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} /* end editmesh */
|
||||
else if (obedit->type==OB_ARMATURE){
|
||||
bArmature *arm= obedit->data;
|
||||
|
@ -113,6 +113,7 @@ const char *imb_ext_movie[] = {
|
||||
".m4v",
|
||||
".m2v",
|
||||
".m2t",
|
||||
".m2ts",
|
||||
".mts",
|
||||
".mv",
|
||||
".avs",
|
||||
|
@ -161,7 +161,7 @@ typedef struct Material {
|
||||
|
||||
int mapto_textured; /* render-time cache to optimise texture lookups */
|
||||
short shadowonly_flag; /* "shadowsonly" type */
|
||||
short pad;
|
||||
short index; /* custom index for render passes */
|
||||
|
||||
ListBase gpumaterial; /* runtime */
|
||||
} Material;
|
||||
|
@ -201,6 +201,7 @@ typedef struct SceneRenderLayer {
|
||||
#define SCE_PASS_RAYHITS (1<<15)
|
||||
#define SCE_PASS_EMIT (1<<16)
|
||||
#define SCE_PASS_ENVIRONMENT (1<<17)
|
||||
#define SCE_PASS_INDEXMA (1<<18)
|
||||
|
||||
/* note, srl->passflag is treestore element 'nr' in outliner, short still... */
|
||||
|
||||
|
@ -509,6 +509,7 @@ static void rna_def_bone_common(StructRNA *srna, int editbone)
|
||||
|
||||
prop= RNA_def_property(srna, "head_radius", PROP_FLOAT, PROP_UNSIGNED);
|
||||
if(editbone) RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
|
||||
else RNA_def_property_update(prop, 0, "rna_Armature_update_data");
|
||||
RNA_def_property_float_sdna(prop, NULL, "rad_head");
|
||||
//RNA_def_property_range(prop, 0, 1000); // XXX range is 0 to lim, where lim= 10000.0f*MAX2(1.0, view3d->grid);
|
||||
RNA_def_property_ui_range(prop, 0.01, 100, 0.1, 3);
|
||||
@ -516,6 +517,7 @@ static void rna_def_bone_common(StructRNA *srna, int editbone)
|
||||
|
||||
prop= RNA_def_property(srna, "tail_radius", PROP_FLOAT, PROP_UNSIGNED);
|
||||
if(editbone) RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
|
||||
else RNA_def_property_update(prop, 0, "rna_Armature_update_data");
|
||||
RNA_def_property_float_sdna(prop, NULL, "rad_tail");
|
||||
//RNA_def_property_range(prop, 0, 1000); // XXX range is 0 to lim, where lim= 10000.0f*MAX2(1.0, view3d->grid);
|
||||
RNA_def_property_ui_range(prop, 0.01, 100, 0.1, 3);
|
||||
|
@ -281,8 +281,7 @@ static int rna_Nurb_length(PointerRNA *ptr)
|
||||
static void rna_Nurb_type_set(PointerRNA *ptr, int value)
|
||||
{
|
||||
Nurb *nu= (Nurb*)ptr->data;
|
||||
nu->type = value;
|
||||
// XXX - TODO change datatypes
|
||||
ED_nurb_set_spline_type(nu, value);
|
||||
}
|
||||
|
||||
static void rna_BPoint_array_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
|
||||
@ -1448,7 +1447,6 @@ static void rna_def_curve_nurb(BlenderRNA *brna)
|
||||
RNA_def_property_ui_text(prop, "Radius Interpolation", "The type of radius interpolation for Bezier curves");
|
||||
RNA_def_property_update(prop, 0, "rna_Curve_update_data");
|
||||
|
||||
// XXX - switching type probably needs comprehensive recalc of data like in 2.4x
|
||||
prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
|
||||
RNA_def_property_enum_items(prop, curve_type_items);
|
||||
RNA_def_property_enum_funcs(prop, NULL, "rna_Nurb_type_set", NULL);
|
||||
|
@ -1676,6 +1676,11 @@ void RNA_def_material(BlenderRNA *brna)
|
||||
RNA_def_property_ui_text(prop, "Light Group", "Limit lighting to lamps in this Group");
|
||||
RNA_def_property_update(prop, 0, "rna_Material_update");
|
||||
|
||||
prop= RNA_def_property(srna, "pass_index", PROP_INT, PROP_UNSIGNED);
|
||||
RNA_def_property_int_sdna(prop, NULL, "index");
|
||||
RNA_def_property_ui_text(prop, "Pass Index", "Index # for the IndexMA render pass");
|
||||
RNA_def_property_update(prop, NC_OBJECT, NULL);
|
||||
|
||||
/* flags */
|
||||
|
||||
prop= RNA_def_property(srna, "use_light_group_exclusive", PROP_BOOLEAN, PROP_NONE);
|
||||
|
@ -270,11 +270,16 @@ static void rna_Base_select_update(Main *UNUSED(bmain), Scene *UNUSED(scene), Po
|
||||
static void rna_Object_layer_update__internal(Main *bmain, Scene *scene, Base *base, Object *ob)
|
||||
{
|
||||
/* try to avoid scene sort */
|
||||
if((ob->lay & scene->lay) && (base->lay & scene->lay)) {
|
||||
if(scene == NULL) {
|
||||
/* pass - unlikely but when running scripts on startup it happens */
|
||||
}
|
||||
else if((ob->lay & scene->lay) && (base->lay & scene->lay)) {
|
||||
/* pass */
|
||||
} else if((ob->lay & scene->lay)==0 && (base->lay & scene->lay)==0) {
|
||||
}
|
||||
else if((ob->lay & scene->lay)==0 && (base->lay & scene->lay)==0) {
|
||||
/* pass */
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
DAG_scene_sort(bmain, scene);
|
||||
}
|
||||
}
|
||||
@ -284,7 +289,7 @@ static void rna_Object_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
|
||||
Object *ob= (Object*)ptr->id.data;
|
||||
Base *base;
|
||||
|
||||
base= object_in_scene(ob, scene);
|
||||
base= scene ? object_in_scene(ob, scene) : NULL;
|
||||
if(!base)
|
||||
return;
|
||||
|
||||
|
@ -585,6 +585,25 @@ static void rna_PoseChannel_matrix_basis_set(PointerRNA *ptr, const float *value
|
||||
pchan_apply_mat4(pchan, (float (*)[4])values, FALSE); /* no compat for predictable result */
|
||||
}
|
||||
|
||||
static void rna_PoseChannel_matrix_set(PointerRNA *ptr, const float *values)
|
||||
{
|
||||
bPoseChannel *pchan= (bPoseChannel*)ptr->data;
|
||||
Object *ob= (Object*)ptr->id.data;
|
||||
float umat[4][4]= MAT4_UNITY;
|
||||
float tmat[4][4];
|
||||
|
||||
/* recalculate pose matrix with only parent transformations,
|
||||
* bone loc/sca/rot is ignored, scene and frame are not used. */
|
||||
where_is_pose_bone(NULL, ob, pchan, 0.0f, FALSE);
|
||||
|
||||
/* find the matrix, need to remove the bone transforms first so this is
|
||||
* calculated as a matrix to set rather then a difference ontop of whats
|
||||
* already there. */
|
||||
pchan_apply_mat4(pchan, umat, FALSE);
|
||||
armature_mat_pose_to_bone(pchan, (float (*)[4])values, tmat);
|
||||
pchan_apply_mat4(pchan, tmat, FALSE); /* no compat for predictable result */
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static void rna_def_bone_group(BlenderRNA *brna)
|
||||
@ -830,8 +849,9 @@ static void rna_def_pose_channel(BlenderRNA *brna)
|
||||
prop= RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
|
||||
RNA_def_property_float_sdna(prop, NULL, "pose_mat");
|
||||
RNA_def_property_multi_array(prop, 2, matrix_dimsize);
|
||||
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
|
||||
RNA_def_property_float_funcs(prop, NULL, "rna_PoseChannel_matrix_set", NULL);
|
||||
RNA_def_property_ui_text(prop, "Pose Matrix", "Final 4x4 matrix after constraints and drivers are applied (object space)");
|
||||
RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
|
||||
|
||||
/* Head/Tail Coordinates (in Pose Space) - Automatically calculated... */
|
||||
prop= RNA_def_property(srna, "head", PROP_FLOAT, PROP_TRANSLATION);
|
||||
|
@ -388,6 +388,7 @@ static void rna_def_render_pass(BlenderRNA *brna)
|
||||
{SCE_PASS_MIST, "MIST", 0, "Mist", ""},
|
||||
{SCE_PASS_EMIT, "EMIT", 0, "Emit", ""},
|
||||
{SCE_PASS_ENVIRONMENT, "ENVIRONMENT", 0, "Environment", ""},
|
||||
{SCE_PASS_INDEXMA, "MATERIAL_INDEX", 0, "Material Index", ""},
|
||||
{0, NULL, 0, NULL, NULL}};
|
||||
|
||||
srna= RNA_def_struct(brna, "RenderPass", NULL);
|
||||
|
@ -1515,6 +1515,12 @@ void rna_def_render_layer_common(StructRNA *srna, int scene)
|
||||
if(scene) RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
|
||||
else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
|
||||
|
||||
prop= RNA_def_property(srna, "use_pass_material_index", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_INDEXMA);
|
||||
RNA_def_property_ui_text(prop, "Material Index", "Deliver material index pass");
|
||||
if(scene) RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
|
||||
else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
|
||||
|
||||
prop= RNA_def_property(srna, "use_pass_color", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_RGBA);
|
||||
RNA_def_property_ui_text(prop, "Color", "Deliver shade-less color pass");
|
||||
|
@ -85,9 +85,9 @@ static void rna_SceneRender_get_frame_path(RenderData *rd, int frame, char *name
|
||||
/* don't remove this, as COLLADA exporting cannot be done through operators in render() callback. */
|
||||
#include "../../collada/collada.h"
|
||||
|
||||
static void rna_Scene_collada_export(Scene *scene, const char *filepath)
|
||||
static void rna_Scene_collada_export(Scene *scene, const char *filepath, int selected)
|
||||
{
|
||||
collada_export(scene, filepath);
|
||||
collada_export(scene, filepath, selected);
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -112,6 +112,7 @@ void RNA_api_scene(StructRNA *srna)
|
||||
/* don't remove this, as COLLADA exporting cannot be done through operators in render() callback. */
|
||||
func= RNA_def_function(srna, "collada_export", "rna_Scene_collada_export");
|
||||
parm= RNA_def_string(func, "filepath", "", FILE_MAX, "File Path", "File path to write Collada file.");
|
||||
parm= RNA_def_boolean(func, "selected", 0, "Export only selected", "Export only selected elements.");
|
||||
RNA_def_property_flag(parm, PROP_REQUIRED);
|
||||
RNA_def_property_subtype(parm, PROP_FILEPATH); /* allow non utf8 */
|
||||
RNA_def_function_ui_description(func, "Export to collada file.");
|
||||
|
@ -53,6 +53,7 @@ static bNodeSocketType cmp_node_rlayers_out[]= {
|
||||
{ SOCK_RGBA, 0, "Refract", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
|
||||
{ SOCK_RGBA, 0, "Indirect", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
|
||||
{ SOCK_VALUE, 0, "IndexOB", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
|
||||
{ SOCK_VALUE, 0, "IndexMA", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
|
||||
{ SOCK_VALUE, 0, "Mist", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
|
||||
{ SOCK_RGBA, 0, "Emit", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
|
||||
{ SOCK_RGBA, 0, "Environment",0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
|
||||
@ -211,6 +212,8 @@ static void outputs_multilayer_get(RenderData *rd, RenderLayer *rl, bNodeStack *
|
||||
out[RRES_OUT_INDIRECT]->data= compbuf_multilayer_get(rd, rl, ima, iuser, SCE_PASS_INDIRECT);
|
||||
if(out[RRES_OUT_INDEXOB]->hasoutput)
|
||||
out[RRES_OUT_INDEXOB]->data= compbuf_multilayer_get(rd, rl, ima, iuser, SCE_PASS_INDEXOB);
|
||||
if(out[RRES_OUT_INDEXMA]->hasoutput)
|
||||
out[RRES_OUT_INDEXMA]->data= compbuf_multilayer_get(rd, rl, ima, iuser, SCE_PASS_INDEXMA);
|
||||
if(out[RRES_OUT_MIST]->hasoutput)
|
||||
out[RRES_OUT_MIST]->data= compbuf_multilayer_get(rd, rl, ima, iuser, SCE_PASS_MIST);
|
||||
if(out[RRES_OUT_EMIT]->hasoutput)
|
||||
@ -326,7 +329,7 @@ static CompBuf *compbuf_from_pass(RenderData *rd, RenderLayer *rl, int rectx, in
|
||||
CompBuf *buf;
|
||||
int buftype= CB_VEC3;
|
||||
|
||||
if(ELEM3(passcode, SCE_PASS_Z, SCE_PASS_INDEXOB, SCE_PASS_MIST))
|
||||
if(ELEM4(passcode, SCE_PASS_Z, SCE_PASS_INDEXOB, SCE_PASS_MIST, SCE_PASS_INDEXMA))
|
||||
buftype= CB_VAL;
|
||||
else if(passcode==SCE_PASS_VECTOR)
|
||||
buftype= CB_VEC4;
|
||||
@ -373,6 +376,8 @@ static void node_composit_rlayers_out(RenderData *rd, RenderLayer *rl, bNodeStac
|
||||
out[RRES_OUT_INDIRECT]->data= compbuf_from_pass(rd, rl, rectx, recty, SCE_PASS_INDIRECT);
|
||||
if(out[RRES_OUT_INDEXOB]->hasoutput)
|
||||
out[RRES_OUT_INDEXOB]->data= compbuf_from_pass(rd, rl, rectx, recty, SCE_PASS_INDEXOB);
|
||||
if(out[RRES_OUT_INDEXMA]->hasoutput)
|
||||
out[RRES_OUT_INDEXMA]->data= compbuf_from_pass(rd, rl, rectx, recty, SCE_PASS_INDEXMA);
|
||||
if(out[RRES_OUT_MIST]->hasoutput)
|
||||
out[RRES_OUT_MIST]->data= compbuf_from_pass(rd, rl, rectx, recty, SCE_PASS_MIST);
|
||||
if(out[RRES_OUT_EMIT]->hasoutput)
|
||||
|
@ -49,18 +49,18 @@ static bNodeSocketType outputs[]= {
|
||||
|
||||
static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, short thread)
|
||||
{
|
||||
Tex *nodetex = (Tex *)node->id;
|
||||
static float red[] = {1,0,0,1};
|
||||
static float white[] = {1,1,1,1};
|
||||
float *co = p->co;
|
||||
float co[3], dxt[3], dyt[3];
|
||||
|
||||
Tex *nodetex = (Tex *)node->id;
|
||||
copy_v3_v3(co, p->co);
|
||||
copy_v3_v3(dxt, p->dxt);
|
||||
copy_v3_v3(dyt, p->dyt);
|
||||
|
||||
if(node->custom2 || node->need_exec==0) {
|
||||
/* this node refers to its own texture tree! */
|
||||
QUATCOPY(
|
||||
out,
|
||||
(fabs(co[0] - co[1]) < .01) ? white : red
|
||||
);
|
||||
QUATCOPY(out, (fabs(co[0] - co[1]) < .01) ? white : red );
|
||||
}
|
||||
else if(nodetex) {
|
||||
TexResult texres;
|
||||
@ -72,7 +72,7 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor
|
||||
tex_input_rgba(col2, in[1], p, thread);
|
||||
|
||||
texres.nor = nor;
|
||||
textype = multitex_nodes(nodetex, co, p->dxt, p->dyt, p->osatex,
|
||||
textype = multitex_nodes(nodetex, co, dxt, dyt, p->osatex,
|
||||
&texres, thread, 0, p->shi, p->mtex);
|
||||
|
||||
if(textype & TEX_RGB) {
|
||||
|
@ -680,7 +680,7 @@ static PyObject *M_Geometry_intersect_line_sphere_2d(PyObject *UNUSED(self), PyO
|
||||
|
||||
PyObject *ret= PyTuple_New(2);
|
||||
|
||||
switch(isect_line_sphere_v3(line_a->vec, line_b->vec, sphere_co->vec, sphere_radius, isect_a, isect_b)) {
|
||||
switch(isect_line_sphere_v2(line_a->vec, line_b->vec, sphere_co->vec, sphere_radius, isect_a, isect_b)) {
|
||||
case 1:
|
||||
if(!(!clip || (((lambda= line_point_factor_v2(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a= FALSE;
|
||||
use_b= FALSE;
|
||||
|
@ -209,8 +209,6 @@ void BPY_python_start(int argc, const char **argv)
|
||||
|
||||
Py_Initialize();
|
||||
|
||||
bpy_intern_string_init();
|
||||
|
||||
// PySys_SetArgv(argc, argv); // broken in py3, not a huge deal
|
||||
/* sigh, why do python guys not have a char** version anymore? :( */
|
||||
{
|
||||
@ -233,6 +231,8 @@ void BPY_python_start(int argc, const char **argv)
|
||||
PyImport_ExtendInittab(bpy_internal_modules);
|
||||
#endif
|
||||
|
||||
bpy_intern_string_init();
|
||||
|
||||
/* bpy.* and lets us import it */
|
||||
BPy_init_modules();
|
||||
|
||||
|
@ -383,6 +383,10 @@ static const char *get_pass_name(int passtype, int channel)
|
||||
if(channel==-1) return "IndexOB";
|
||||
return "IndexOB.X";
|
||||
}
|
||||
if(passtype == SCE_PASS_INDEXMA) {
|
||||
if(channel==-1) return "IndexMA";
|
||||
return "IndexMA.X";
|
||||
}
|
||||
if(passtype == SCE_PASS_MIST) {
|
||||
if(channel==-1) return "Mist";
|
||||
return "Mist.Z";
|
||||
@ -448,6 +452,9 @@ static int passtype_from_name(char *str)
|
||||
if(strcmp(str, "IndexOB")==0)
|
||||
return SCE_PASS_INDEXOB;
|
||||
|
||||
if(strcmp(str, "IndexMA")==0)
|
||||
return SCE_PASS_INDEXMA;
|
||||
|
||||
if(strcmp(str, "Mist")==0)
|
||||
return SCE_PASS_MIST;
|
||||
|
||||
@ -631,6 +638,8 @@ static RenderResult *new_render_result(Render *re, rcti *partrct, int crop, int
|
||||
render_layer_add_pass(rr, rl, 3, SCE_PASS_REFRACT);
|
||||
if(srl->passflag & SCE_PASS_INDEXOB)
|
||||
render_layer_add_pass(rr, rl, 1, SCE_PASS_INDEXOB);
|
||||
if(srl->passflag & SCE_PASS_INDEXMA)
|
||||
render_layer_add_pass(rr, rl, 1, SCE_PASS_INDEXMA);
|
||||
if(srl->passflag & SCE_PASS_MIST)
|
||||
render_layer_add_pass(rr, rl, 1, SCE_PASS_MIST);
|
||||
if(rl->passflag & SCE_PASS_RAYHITS)
|
||||
|
@ -515,6 +515,14 @@ static void add_filt_passes(RenderLayer *rl, int curmask, int rectx, int offset,
|
||||
*fp= (float)shi->obr->ob->index;
|
||||
}
|
||||
break;
|
||||
case SCE_PASS_INDEXMA:
|
||||
/* no filter */
|
||||
if(shi->vlr) {
|
||||
fp= rpass->rect + offset;
|
||||
if(*fp==0.0f)
|
||||
*fp= (float)shi->mat->index;
|
||||
}
|
||||
break;
|
||||
case SCE_PASS_MIST:
|
||||
/* */
|
||||
col= &shr->mist;
|
||||
@ -619,6 +627,12 @@ static void add_passes(RenderLayer *rl, int offset, ShadeInput *shi, ShadeResult
|
||||
*fp= (float)shi->obr->ob->index;
|
||||
}
|
||||
break;
|
||||
case SCE_PASS_INDEXMA:
|
||||
if(shi->vlr) {
|
||||
fp= rpass->rect + offset;
|
||||
*fp= (float)shi->mat->index;
|
||||
}
|
||||
break;
|
||||
case SCE_PASS_MIST:
|
||||
fp= rpass->rect + offset;
|
||||
*fp= shr->mist;
|
||||
|
@ -771,7 +771,8 @@ void shade_input_set_uv(ShadeInput *shi)
|
||||
t00= v3[axis1]-v1[axis1]; t01= v3[axis2]-v1[axis2];
|
||||
t10= v3[axis1]-v2[axis1]; t11= v3[axis2]-v2[axis2];
|
||||
|
||||
detsh= 1.0f/(t00*t11-t10*t01);
|
||||
detsh= (t00*t11-t10*t01);
|
||||
detsh= (detsh != 0.0f)? 1.0f/detsh: 0.0f;
|
||||
t00*= detsh; t01*=detsh;
|
||||
t10*=detsh; t11*=detsh;
|
||||
|
||||
@ -1272,8 +1273,9 @@ void shade_input_set_shade_texco(ShadeInput *shi)
|
||||
s11= ho3[1]/ho3[3] - ho2[1]/ho2[3];
|
||||
|
||||
detsh= s00*s11-s10*s01;
|
||||
s00/= detsh; s01/=detsh;
|
||||
s10/=detsh; s11/=detsh;
|
||||
detsh= (detsh != 0.0f)? 1.0f/detsh: 0.0f;
|
||||
s00*= detsh; s01*=detsh;
|
||||
s10*=detsh; s11*=detsh;
|
||||
|
||||
/* recalc u and v again */
|
||||
hox= x/Zmulx -1.0f;
|
||||
@ -1455,7 +1457,7 @@ int shade_samples(ShadeSample *ssamp, PixStr *ps, int x, int y)
|
||||
shade_samples_do_AO(ssamp);
|
||||
|
||||
/* if shade (all shadepinputs have same passflag) */
|
||||
if(ssamp->shi[0].passflag & ~(SCE_PASS_Z|SCE_PASS_INDEXOB)) {
|
||||
if(ssamp->shi[0].passflag & ~(SCE_PASS_Z|SCE_PASS_INDEXOB|SCE_PASS_INDEXMA)) {
|
||||
|
||||
for(samp=0; samp<ssamp->tot; samp++, shi++, shr++) {
|
||||
shade_input_set_shade_texco(shi);
|
||||
|
@ -3497,7 +3497,7 @@ static void add_transp_obindex(RenderLayer *rl, int offset, Object *ob)
|
||||
RenderPass *rpass;
|
||||
|
||||
for(rpass= rl->passes.first; rpass; rpass= rpass->next) {
|
||||
if(rpass->passtype == SCE_PASS_INDEXOB) {
|
||||
if(rpass->passtype == SCE_PASS_INDEXOB||rpass->passtype == SCE_PASS_INDEXMA) {
|
||||
float *fp= rpass->rect + offset;
|
||||
*fp= (float)ob->index;
|
||||
break;
|
||||
@ -3820,7 +3820,7 @@ static int shade_tra_samples(ShadeSample *ssamp, StrandShadeCache *cache, int x,
|
||||
shade_samples_do_AO(ssamp);
|
||||
|
||||
/* if shade (all shadepinputs have same passflag) */
|
||||
if(shi->passflag & ~(SCE_PASS_Z|SCE_PASS_INDEXOB)) {
|
||||
if(shi->passflag & ~(SCE_PASS_Z|SCE_PASS_INDEXOB|SCE_PASS_INDEXMA)) {
|
||||
for(samp=0; samp<ssamp->tot; samp++, shi++, shr++) {
|
||||
shade_input_set_shade_texco(shi);
|
||||
shade_input_do_shade(shi, shr);
|
||||
@ -4115,6 +4115,13 @@ unsigned short *zbuffer_transp_shade(RenderPart *pa, RenderLayer *rl, float *pas
|
||||
add_transp_obindex(rlpp[a], od, obr->ob);
|
||||
}
|
||||
}
|
||||
if(addpassflag & SCE_PASS_INDEXMA) {
|
||||
ObjectRen *obr= R.objectinstance[zrow[totface-1].obi].obr;
|
||||
if(obr->ob) {
|
||||
for(a= 0; a<totfullsample; a++)
|
||||
add_transp_obindex(rlpp[a], od, obr->ob);
|
||||
}
|
||||
}
|
||||
|
||||
/* for each mask-sample we alpha-under colors. then in end it's added using filter */
|
||||
memset(samp_shr, 0, sizeof(ShadeResult)*osa);
|
||||
|
@ -636,7 +636,8 @@ static ImBuf *blend_file_thumb(Scene *scene, int **thumb_pt)
|
||||
|
||||
*thumb_pt= NULL;
|
||||
|
||||
if(G.background || scene->camera==NULL)
|
||||
/* scene can be NULL if running a script at startup and calling the save operator */
|
||||
if(G.background || scene==NULL || scene->camera==NULL)
|
||||
return NULL;
|
||||
|
||||
/* gets scaled to BLEN_THUMB_SIZE */
|
||||
|
@ -2004,6 +2004,8 @@ static void WM_OT_save_mainfile(wmOperatorType *ot)
|
||||
|
||||
static int wm_collada_export_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
|
||||
{
|
||||
int selected = 0;
|
||||
|
||||
if(!RNA_property_is_set(op->ptr, "filepath")) {
|
||||
char filepath[FILE_MAX];
|
||||
BLI_strncpy(filepath, G.main->name, sizeof(filepath));
|
||||
@ -2020,6 +2022,7 @@ static int wm_collada_export_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED
|
||||
static int wm_collada_export_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
char filename[FILE_MAX];
|
||||
int selected;
|
||||
|
||||
if(!RNA_property_is_set(op->ptr, "filepath")) {
|
||||
BKE_report(op->reports, RPT_ERROR, "No filename given");
|
||||
@ -2027,7 +2030,8 @@ static int wm_collada_export_exec(bContext *C, wmOperator *op)
|
||||
}
|
||||
|
||||
RNA_string_get(op->ptr, "filepath", filename);
|
||||
if(collada_export(CTX_data_scene(C), filename)) {
|
||||
selected = RNA_boolean_get(op->ptr, "selected");
|
||||
if(collada_export(CTX_data_scene(C), filename, selected)) {
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
else {
|
||||
@ -2045,6 +2049,8 @@ static void WM_OT_collada_export(wmOperatorType *ot)
|
||||
ot->poll= WM_operator_winactive;
|
||||
|
||||
WM_operator_properties_filesel(ot, FOLDERFILE|COLLADAFILE, FILE_BLENDER, FILE_SAVE, WM_FILESEL_FILEPATH);
|
||||
RNA_def_boolean(ot->srna, "selected", 0, "Export only selected",
|
||||
"Export only selected elements");
|
||||
}
|
||||
|
||||
/* function used for WM_OT_save_mainfile too */
|
||||
|
@ -139,6 +139,10 @@ endif()
|
||||
bf_intern_mikktspace
|
||||
)
|
||||
|
||||
if(WITH_MOD_CLOTH_ELTOPO)
|
||||
list(APPEND BLENDER_SORTED_LIBS extern_eltopo)
|
||||
endif()
|
||||
|
||||
if(WITH_BUILTIN_GLEW)
|
||||
list(APPEND BLENDER_SORTED_LIBS extern_glew)
|
||||
endif()
|
||||
|
@ -68,6 +68,7 @@ struct Mesh;
|
||||
struct ModifierData;
|
||||
struct MultiresModifierData;
|
||||
struct NodeBlurData;
|
||||
struct Nurb;
|
||||
struct Object;
|
||||
struct PBVHNode;
|
||||
struct Render;
|
||||
@ -293,7 +294,8 @@ float ED_rollBoneToVector(struct EditBone *bone, float new_up_axis[3]){return 0.
|
||||
void ED_space_image_size(struct SpaceImage *sima, int *width, int *height){}
|
||||
|
||||
struct ListBase *ED_curve_editnurbs(struct Curve *cu){return NULL;}
|
||||
void free_curve_editNurb (struct Curve *cu){};
|
||||
void free_curve_editNurb (struct Curve *cu){}
|
||||
void ED_nurb_set_spline_type(struct Nurb *nu, int type){}
|
||||
|
||||
void EM_selectmode_set(struct EditMesh *em){}
|
||||
int EM_texFaceCheck(struct EditMesh *em){return 0;}
|
||||
|
@ -64,6 +64,7 @@ extern "C"
|
||||
#include "BKE_node.h"
|
||||
#include "BKE_report.h"
|
||||
#include "BKE_library.h"
|
||||
#include "BLI_threads.h"
|
||||
#include "BLI_blenlib.h"
|
||||
#include "DNA_scene_types.h"
|
||||
#include "DNA_userdef_types.h"
|
||||
@ -400,6 +401,10 @@ int main(int argc, char** argv)
|
||||
*/
|
||||
#endif // __APPLE__
|
||||
|
||||
// We don't use threads directly in the BGE, but we need to call this so things like
|
||||
// freeing up GPU_Textures works correctly.
|
||||
BLI_threadapi_init();
|
||||
|
||||
RNA_init();
|
||||
|
||||
init_nodesystem();
|
||||
|
@ -40,6 +40,8 @@ incs = ['.',
|
||||
'#source/blender/gpu',
|
||||
'#extern/glew/include']
|
||||
|
||||
incs.append(env['BF_PTHREADS_INC'])
|
||||
|
||||
defs = [ 'GLEW_STATIC' ]
|
||||
|
||||
if env['WITH_BF_PYTHON']:
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user