- added mesh_get_derived_deform function (always returns a DerivedMesh
corresponding to deformed (but not subdivided) mesh). used in places
where original mesh is to be displayed but with deformed coordinates
(vpaint for example).
- added DirectMesh.getVert{Co,No} implementations for MeshDerivedMesh
- updated vpaint to use mesh_get_derived_deform
- changed mesh_get_derived_render to always return a DerivedMesh (even if
no subsurf)
- changed init_render_mesh to always get the mesh data through a
DerivedMesh
situations where data can be shared easily.
- added convertDisplistToMesh function for regular mesh DerivedMesh
interface (how many times can *you* use mesh in one sentence?)
- do_puno was uninitialized in init_render_mesh
- added mesh_get_derived_final (temporary), difference from
mesh_get_derived is it always returns a derived mesh, even if
no subsurf.
The B-Bones!
(where the B can be read as 'block' or 'bezier' or 'b-spline')
- set option on/off in edit buttons, armature panel
- scaling of B-bones only works in editmode, use ALT+S to make bones fatter
or thinner. Also works for constrainted transform
- In pose mode, you now have a buttons panel with per-bone settings too
Here you can find the "segments" button, which allows bones to
interpolate between previous/next bones, including roll.
- Buttons to control interpolation ("In" and "Out" are disabled, doesn't
work satisfying yet
NOTE: this doesn't give deform yet! Main purpose for now is to test if this
drawing method serves to animate/pose armatures well.
Still need to review proper interpolation methods... maybe bezier is too
limited.
This will improve collision detection and physics for the game engine (Ketsji).
Bullet uses optionally uses the ODE quickstep solver.
Hope this commit doesn't break everything.
- appropriate callers of makeDispList replaced with depgraph calls
- unappropriate places just killed... small chance this gives some
errors in corner cases if dep graph isn't notified (example, font
family displists) but these can be tracked down as they show up.
- still a large number of callers of makeDispListCurveTypes, but
makeDispListMesh has just a few.
to that in editmesh as well as for edit{curve,lattice}
- added a G.editModeTitleExtra string that gets displayed in header info
string in editmode. currently used to display "(Key)" when editing a
key (before there was not UI level display of this info).
This adds two new method to the BPY Object type:
- makeParentDeform
- makeParentVertex
Both are based on makeParent. In fact, I splitted off the parenting
part of makeParent into an internal function so that all can reuse it. I
also added DEP_graph refresh flag that where missing.
makeParentDeform sets the parent type accordingly for correct
deformation (armature and curve) and checks if the parent and childs are of the
correct type for deformation.
makeParentVertex takes as additional mandatory argument a tuple of
indices to tell the parent which vertex to use. It does some object type
checking too.
Also included documentation. :)
Test file is in the patch there: http://projects.blender.org/tracker/?func=detail&atid=127&aid=2833&group_id=9
Note to Ton: When doing vertex parenting, the dashed parent line is only updated correctly if the objects are on screen when calling the function. If they aren't, the line is wrong and is only corrected when another recalc is called on the parent or child.
- some other twiddles to fix mixed signedness compiler warnings
And from the "Dear lazy programmers" file: After you have extern declared
a variable 5 or more times at the top a function, you would have actually
saved a lot of effort by just putting it in the header where it belonged.
Or perhaps you thought by hiding it no one else would notice you were
using global variables to pass information around. Tsk tsk.
which calculates texspace on demand if need be.
- removed almost all calls to tex_space_mesh
There may be a few corner cases where this goes wrong (meshes with vertex
keys) but these should get ironed out by coming modifier system.
- switch all mesh boundbox access to go through mesh_get_bb
- switch object_handle_update to call mesh_changed instead of making
the displist data immediately (delayed calculation)
Setting both 'xray' and 'transp' did not work proper. Had to add one
extra check, and switch drawing order. Now a transparent object gets
drawn OK as Xray too. :)
still a makeDispList that dispatches to the appropriate one.
makeDispList is on the way out and this makes it easier to track down
exactly which places use makedispList and for what types of objects.
- switch calls to makeDispList to appropriate more specific function (if
the object type is known by caller).
- added mesh_changed function that invalidates cached mesh data (but does
not rebuild, mesh data gets rebuilt on access). Most old calls to
makeDispListMesh use this instead now.
back to 1.4 - comparing pointers apparently gave warnings or errors... I
don't really have a memory of that. Could be the Irix compiler.
What it was used for is sorting edges in arrays or hash lists, like:
if( ((long)v1) > ((long)v2) )
long is defined to be pointer size, so that should work 32/64 bits, where
it not that the long cast makes the value SIGNED! :)
Ken Hughes discovered this... noting that when his system uses a calloc, the
returned pointer had an uncommon address making the long negative.
It was a very hard bug to track, since (apparently) most OS's have an address
space being still in the lower part of an long...
Anyhoo; I have removed a couple of (long) casts from pointer comparing now,
need to get compile feedback if that's compliant for all our OS's.
If so, quite a lot of such hacks have to be removed from our code, or make
them casting to an unsigned long...
This has been confirmed to fix bugs #2709 and #2710. Thanks Ken!
- XRAY draw for armatures now is generic "Draw Extra" option for any
Object type. This feature just moves drawing to the end, after clearing
the zbuffer again.
- Solid draw mode now displays materials with Alpha, with the new
"Draw extra" option "Transp" set. This also moves drawing transparent to
the end, but it doesn't sort the transparent faces. Still looks OK.
Note: this is not enabled in mesh editmode. Here all the fancy extra
drawing just makes it nearly impossible to do OK.
- Re-ordered Object Buttons -> "Draw" panel
Fixes:
- do_versions had check for the UserDef in it (new ogl texture cache).
that can't be there, should be in usiblender.c (stupid exception).
- same error caused reading older files to not always fix version
changes on armatures (commit yesterday).
- Outline select drawing happened also on picking-select draw, needless
slowdown.
- also included is some fixes for preprocessor inclues and some clean up of the previous commit
-rewrite and bugfixes
----------------------------------
Here's my changelog:
-fixed Rand() so that it doesn't seed everytime and should generate better random numbers
- changed a few error return types to something more appropriate
- clean up of uninitialized variables & removal of unneccessary objects
- NMesh returns wrapped vectors now
- World returns wrapped matrices now
- Object.getEuler() and Object.getBoundingBox() return Wrapped data when data is present
- Object.getMatrix() returns wrapped data if it's worldspace, 'localspace' returns a new matrix
- Vector, Euler, Mat, Quat, call all now internally wrap object without destroying internal datablocks
- Removed memory allocation (unneeded) from all methods
- Vector's resize methods are only applicable to new vectors not wrapped data.
- Matrix(), Quat(), Euler(), Vector() now accepts ANY sequence list, including tuples, list, or a self object to copy - matrices accept multiple sequences
- Fixed Slerp() so that it now works correctly values are clamped between 0 and 1
- Euler.rotate does internal rotation now
- Slice assignment now works better for all types
- Vector * Vector and Quat * Quat are defined and return the DOT product
- Mat * Vec and Vec * Mat are defined now
- Moved #includes to .c file from headers. Also fixed prototypes in mathutils
- Added new helper functions for incref'ing to genutils
- Major cleanup of header files includes - include Mathutils.h for access to math types
- matrix.toQuat() and .toEuler() now fixed take appropriate matrix sizes
- Matrix() with no parameters now returns an identity matrix by default not a zero matrix
- printf() now prints with 6 digits instead of 4
- printf() now prints output with object descriptor
- Matrices now support [x][y] assignment (e.g. matrix[x][y] = 5.4)
- Matrix[index] = value now expectes a sequence not an integer. This will now set a ROW of the matrix through a sequence. index cannot go above the row size of the matrix.
- slice operations on matrices work with sequences now (rows of the matrix) example: mymatrix[0:2] returns a list of 2 wrapped vectors with access to the matrix data.
- slice assignment will no longer modify the data if the assignment operation fails
- fixed error in matrix * scalar multiplication
- euler.toMatrix(), toQuat() no longer causes "creep" from repeated use
- Wrapped data will generate wrapped objects when toEuler(), toQuat(), toMatrix() is used
- Quats can be created with angle/axis, axis/angle
- 4x4 matrices can be multiplied by 3D vectors (by popular demand :))
- vec *quat / quat * vec is now defined
- vec.magnitude alias for vec.length
- all self, internal methods return a pointer to self now so you can do print vector.internalmethod() or vector.internalmethod().nextmethod() (no more print matrix.inverse() returning 'none')
- these methods have been deprecated (still functioning but suggested to use the corrected functionality):
* CopyVec() - replaced by Vector() functionality
* CopyMat() - replaced by Matrix() functionality
* CopyQuat() - replace by Quaternion() functionality
* CopyEuler() - replaced by Euler() functionality
* RotateEuler() - replaced by Euler.rotate() funtionality
* MatMultVec() - replaced by matrix * vector
* VecMultMat() - replaced by vector * matrix
- New struct containers references to python object data or internally allocated blender data for wrapping
* Explaination here: math structs now function as a 'simple wrapper' or a 'py_object' - data that is created on the fly will now be a 'py_object' with its memory managed by python
* otherwise if the data is returned by blender's G.main then the math object is a 'simple wrapper' and data can be accessed directly from the struct just like other python objects.
