forked from bartvdbraak/blender
Cleanup: use single back-tick quoting in comments
While doxygen supports both, conform to our style guide. Note that single back-tick's are already used in a majority of comments.
This commit is contained in:
parent
48a45c43e4
commit
c3a400b73f
2
extern/rangetree/intern/generic_alloc_impl.h
vendored
2
extern/rangetree/intern/generic_alloc_impl.h
vendored
@ -32,7 +32,7 @@
|
||||
* - #TPOOL_STRUCT: Name for pool struct name.
|
||||
* - #TPOOL_CHUNK_SIZE: Chunk size (optional), use 64kb when not defined.
|
||||
*
|
||||
* \note #TPOOL_ALLOC_TYPE must be at least ``sizeof(void *)``.
|
||||
* \note #TPOOL_ALLOC_TYPE must be at least `sizeof(void *)`.
|
||||
*
|
||||
* Defines the API, uses #TPOOL_IMPL_PREFIX to prefix each function.
|
||||
*
|
||||
|
@ -158,7 +158,7 @@ struct DerivedMesh {
|
||||
int (*getNumPolys)(DerivedMesh *dm);
|
||||
|
||||
/** Copy a single vert/edge/tessellated face from the derived mesh into
|
||||
* ``*r_{vert/edge/face}``. note that the current implementation
|
||||
* `*r_{vert/edge/face}`. note that the current implementation
|
||||
* of this function can be quite slow, iterating over all
|
||||
* elements (editmesh)
|
||||
*/
|
||||
|
@ -135,8 +135,8 @@ static void imbuf_save_post(ImBuf *ibuf, ImBuf *colormanaged_ibuf)
|
||||
|
||||
/**
|
||||
* \return success.
|
||||
* \note ``ima->filepath`` and ``ibuf->name`` should end up the same.
|
||||
* \note for multiview the first ``ibuf`` is important to get the settings.
|
||||
* \note `ima->filepath` and `ibuf->name` should end up the same.
|
||||
* \note for multi-view the first `ibuf` is important to get the settings.
|
||||
*/
|
||||
static bool image_save_single(ReportList *reports,
|
||||
Image *ima,
|
||||
|
@ -49,9 +49,9 @@
|
||||
* \{ */
|
||||
|
||||
struct IDNameLib_Key {
|
||||
/** ``ID.name + 2``: without the ID type prefix, since each id type gets its own 'map' */
|
||||
/** `ID.name + 2`: without the ID type prefix, since each id type gets its own 'map'. */
|
||||
const char *name;
|
||||
/** ``ID.lib``: */
|
||||
/** `ID.lib`: */
|
||||
const Library *lib;
|
||||
};
|
||||
|
||||
|
@ -305,7 +305,7 @@ static void build_bvh_spatial(PROCESS *process,
|
||||
|
||||
/**
|
||||
* Computes density from given metaball at given position.
|
||||
* Metaball equation is: ``(1 - r^2 / R^2)^3 * s``
|
||||
* Metaball equation is: `(1 - r^2 / R^2)^3 * s`
|
||||
*
|
||||
* r = distance from center
|
||||
* R = metaball radius
|
||||
|
@ -539,8 +539,8 @@ void BKE_mesh_edge_poly_map_create(MeshElemMap **r_map,
|
||||
* \param totfinal: The size of \a final_origindex
|
||||
* \param final_origindex: The size of the final array.
|
||||
*
|
||||
* \note ``totsource`` could be ``totpoly``,
|
||||
* ``totfinal`` could be ``tottessface`` and ``final_origindex`` its ORIGINDEX customdata.
|
||||
* \note `totsource` could be `totpoly`,
|
||||
* `totfinal` could be `tottessface` and `final_origindex` its ORIGINDEX custom-data.
|
||||
* This would allow an MPoly to loop over its tessfaces.
|
||||
*/
|
||||
void BKE_mesh_origindex_map_create(MeshElemMap **r_map,
|
||||
|
@ -1168,12 +1168,12 @@ static void pbvh_bmesh_split_edge(EdgeQueueContext *eq_ctx,
|
||||
}
|
||||
|
||||
/**
|
||||
* The 2 new faces created and assigned to ``f_new`` have their
|
||||
* The 2 new faces created and assigned to `f_new` have their
|
||||
* verts & edges shuffled around.
|
||||
*
|
||||
* - faces wind anticlockwise in this example.
|
||||
* - original edge is ``(v1, v2)``
|
||||
* - original face is ``(v1, v2, v3)``
|
||||
* - original edge is `(v1, v2)`
|
||||
* - original face is `(v1, v2, v3)`
|
||||
*
|
||||
* <pre>
|
||||
* + v3(v_opp)
|
||||
@ -1189,8 +1189,8 @@ static void pbvh_bmesh_split_edge(EdgeQueueContext *eq_ctx,
|
||||
* (first) (second)
|
||||
* </pre>
|
||||
*
|
||||
* - f_new (first): ``v_tri=(v1, v4, v3), e_tri=(e1, e5, e4)``
|
||||
* - f_new (second): ``v_tri=(v4, v2, v3), e_tri=(e2, e3, e5)``
|
||||
* - f_new (first): `v_tri=(v1, v4, v3), e_tri=(e1, e5, e4)`
|
||||
* - f_new (second): `v_tri=(v4, v2, v3), e_tri=(e2, e3, e5)`
|
||||
*/
|
||||
|
||||
/* Create two new faces */
|
||||
|
@ -2105,7 +2105,7 @@ Object *BKE_scene_object_find_by_name(const Scene *scene, const char *name)
|
||||
|
||||
/**
|
||||
* Sets the active scene, mainly used when running in background mode
|
||||
* (``--scene`` command line argument).
|
||||
* (`--scene` command line argument).
|
||||
* This is also called to set the scene directly, bypassing windowing code.
|
||||
* Otherwise #WM_window_set_active_scene is used when changing scenes by the user.
|
||||
*/
|
||||
@ -3242,9 +3242,9 @@ void BKE_scene_multiview_filepath_get(SceneRenderView *srv, const char *filepath
|
||||
}
|
||||
|
||||
/**
|
||||
* When multiview is not used the filepath is as usual (e.g., ``Image.jpg``).
|
||||
* When multiview is not used the filepath is as usual (e.g., `Image.jpg`).
|
||||
* When multiview is on, even if only one view is enabled the view is incorporated
|
||||
* into the file name (e.g., ``Image_L.jpg``). That allows for the user to re-render
|
||||
* into the file name (e.g., `Image_L.jpg`). That allows for the user to re-render
|
||||
* individual views.
|
||||
*/
|
||||
void BKE_scene_multiview_view_filepath_get(const RenderData *rd,
|
||||
|
@ -58,7 +58,7 @@ void _bli_array_grow_func(void **arr_p,
|
||||
/** \name Public defines
|
||||
* \{ */
|
||||
|
||||
/** use ``sizeof(*(arr))`` to ensure the array exists and is an array */
|
||||
/** use `sizeof(*(arr))` to ensure the array exists and is an array */
|
||||
#define BLI_array_declare(arr) \
|
||||
int _##arr##_len = ((void)(sizeof(*(arr))), 0); \
|
||||
void *_##arr##_static = NULL
|
||||
|
@ -34,11 +34,11 @@ namespace blender {
|
||||
* Usage:
|
||||
*
|
||||
* Convert a theme byte color to a linearrgb premultiplied.
|
||||
* ```
|
||||
* \code{.cc}
|
||||
* ColorTheme4b theme_color;
|
||||
* ColorSceneLinear4f<eAlpha::Premultiplied> linearrgb_color =
|
||||
* BLI_color_convert_to_scene_linear(theme_color).premultiply_alpha();
|
||||
* ```
|
||||
* \endcode
|
||||
*
|
||||
* The API is structured to make most use of inlining. Most notable are space
|
||||
* conversions done via `BLI_color_convert_to*` functions.
|
||||
|
@ -86,7 +86,7 @@
|
||||
|
||||
/**
|
||||
* CHECK_TYPE_ANY: handy macro, eg:
|
||||
* ``CHECK_TYPE_ANY(var, Foo *, Bar *, Baz *)``
|
||||
* `CHECK_TYPE_ANY(var, Foo *, Bar *, Baz *)`
|
||||
*
|
||||
* excuse ridiculously long generated args.
|
||||
* \code{.py}
|
||||
|
@ -77,7 +77,7 @@ enum {
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name GHash API
|
||||
*
|
||||
* Defined in ``BLI_ghash.c``
|
||||
* Defined in `BLI_ghash.c`
|
||||
* \{ */
|
||||
|
||||
GHash *BLI_ghash_new_ex(GHashHashFP hashfp,
|
||||
@ -333,11 +333,11 @@ double BLI_gset_calc_quality(GSet *gs);
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name GHash/GSet Utils
|
||||
*
|
||||
* Defined in ``BLI_ghash_utils.c``
|
||||
* Defined in `BLI_ghash_utils.c`
|
||||
* \{ */
|
||||
|
||||
/**
|
||||
* Callbacks for GHash (``BLI_ghashutil_``)
|
||||
* Callbacks for GHash (`BLI_ghashutil_`)
|
||||
*
|
||||
* \note '_p' suffix denotes void pointer arg,
|
||||
* so we can have functions that take correctly typed args too.
|
||||
|
@ -20,7 +20,7 @@
|
||||
* \ingroup bli
|
||||
* \brief Single link-list utility macros. (header only api).
|
||||
*
|
||||
* Use this api when the structure defines its own ``next`` pointer
|
||||
* Use this api when the structure defines its own `next` pointer
|
||||
* and a double linked list such as #ListBase isn't needed.
|
||||
*/
|
||||
|
||||
|
@ -28,7 +28,7 @@
|
||||
* \note These macros follow STACK_* macros defined in 'BLI_utildefines.h'
|
||||
* and should be kept (mostly) interchangeable.
|
||||
*
|
||||
* \note ``_##var##_type`` is a dummy variable only used for typechecks.
|
||||
* \note `_##var##_type` is a dummy variable only used for type-checks.
|
||||
*/
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
|
@ -26,32 +26,32 @@
|
||||
*
|
||||
* \section mathabbrev Abbreviations
|
||||
*
|
||||
* - ``fl`` = float
|
||||
* - ``db`` = double
|
||||
* - ``v2`` = vec2 = vector 2
|
||||
* - ``v3`` = vec3 = vector 3
|
||||
* - ``v4`` = vec4 = vector 4
|
||||
* - ``vn`` = vec4 = vector N dimensions, *passed as an arg, after the vector*.
|
||||
* - ``qt`` = quat = quaternion
|
||||
* - ``dq`` = dquat = dual quaternion
|
||||
* - ``m2`` = mat2 = matrix 2x2
|
||||
* - ``m3`` = mat3 = matrix 3x3
|
||||
* - ``m4`` = mat4 = matrix 4x4
|
||||
* - ``eul`` = euler rotation
|
||||
* - ``eulO`` = euler with order
|
||||
* - ``plane`` = plane 4, (vec3, distance)
|
||||
* - ``plane3`` = plane 3 (same as a ``plane`` with a zero 4th component)
|
||||
* - `fl` = float
|
||||
* - `db` = double
|
||||
* - `v2` = vec2 = vector 2
|
||||
* - `v3` = vec3 = vector 3
|
||||
* - `v4` = vec4 = vector 4
|
||||
* - `vn` = vec4 = vector N dimensions, *passed as an arg, after the vector*.
|
||||
* - `qt` = quat = quaternion
|
||||
* - `dq` = dquat = dual quaternion
|
||||
* - `m2` = mat2 = matrix 2x2
|
||||
* - `m3` = mat3 = matrix 3x3
|
||||
* - `m4` = mat4 = matrix 4x4
|
||||
* - `eul` = euler rotation
|
||||
* - `eulO` = euler with order
|
||||
* - `plane` = plane 4, (vec3, distance)
|
||||
* - `plane3` = plane 3 (same as a `plane` with a zero 4th component)
|
||||
*
|
||||
* \subsection mathabbrev_all Function Type Abbreviations
|
||||
*
|
||||
* For non float versions of functions (which typically operate on floats),
|
||||
* use single suffix abbreviations.
|
||||
*
|
||||
* - ``_d`` = double
|
||||
* - ``_i`` = int
|
||||
* - ``_u`` = unsigned int
|
||||
* - ``_char`` = char
|
||||
* - ``_uchar`` = unsigned char
|
||||
* - `_d` = double
|
||||
* - `_i` = int
|
||||
* - `_u` = unsigned int
|
||||
* - `_char` = char
|
||||
* - `_uchar` = unsigned char
|
||||
*
|
||||
* \section mathvarnames Variable Names
|
||||
*
|
||||
|
@ -291,7 +291,7 @@ int BLI_dynstr_get_len(const DynStr *ds)
|
||||
/**
|
||||
* Get a DynStr's contents as a c-string.
|
||||
* The \a rets argument must be allocated to be at
|
||||
* least the size of ``BLI_dynstr_get_len(ds) + 1``.
|
||||
* least the size of `BLI_dynstr_get_len(ds) + 1`.
|
||||
*
|
||||
* \param ds: The DynStr of interest.
|
||||
* \param rets: The string to fill.
|
||||
|
@ -1270,7 +1270,7 @@ void BLI_gset_flag_clear(GSet *gs, uint flag)
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name GSet Combined Key/Value Usage
|
||||
*
|
||||
* \note Not typical ``set`` use, only use when the pointer identity matters.
|
||||
* \note Not typical `set` use, only use when the pointer identity matters.
|
||||
* This can be useful when the key references data stored outside the GSet.
|
||||
* \{ */
|
||||
|
||||
|
@ -138,8 +138,8 @@ size_t BLI_ghashutil_combine_hash(size_t hash_a, size_t hash_b)
|
||||
* This function implements the widely used "djb" hash apparently posted
|
||||
* by Daniel Bernstein to comp.lang.c some time ago. The 32 bit
|
||||
* unsigned hash value starts at 5381 and for each byte 'c' in the
|
||||
* string, is updated: ``hash = hash * 33 + c``. This
|
||||
* function uses the signed value of each byte.
|
||||
* string, is updated: `hash = hash * 33 + c`.
|
||||
* This function uses the signed value of each byte.
|
||||
*
|
||||
* NOTE: this is the same hash method that glib 2.34.0 uses.
|
||||
*/
|
||||
|
@ -868,7 +868,7 @@ static void non_recursive_bvh_div_nodes(const BVHTree *tree,
|
||||
* \{ */
|
||||
|
||||
/**
|
||||
* \note many callers don't check for ``NULL`` return.
|
||||
* \note many callers don't check for `NULL` return.
|
||||
*/
|
||||
BVHTree *BLI_bvhtree_new(int maxsize, float epsilon, char tree_type, char axis)
|
||||
{
|
||||
|
@ -73,7 +73,7 @@ typedef struct BLI_memiter_chunk {
|
||||
struct BLI_memiter_chunk *next;
|
||||
/**
|
||||
* internal format is:
|
||||
* ``[next_pointer, size:data, size:data, ..., negative_offset]``
|
||||
* `[next_pointer, size:data, size:data, ..., negative_offset]`
|
||||
*
|
||||
* Where negative offset rewinds to the start.
|
||||
*/
|
||||
|
@ -63,9 +63,9 @@
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Important that this value is an is _not_ aligned with ``sizeof(void *)``.
|
||||
* Important that this value is an is _not_ aligned with `sizeof(void *)`.
|
||||
* So having a pointer to 2/4/8... aligned memory is enough to ensure
|
||||
* the freeword will never be used.
|
||||
* the `freeword` will never be used.
|
||||
* To be safe, use a word that's the same in both directions.
|
||||
*/
|
||||
#define FREEWORD \
|
||||
|
@ -1403,16 +1403,16 @@ static BChunkList *bchunk_list_from_data_merge(const BArrayInfo *info,
|
||||
* Create a new array store, which can store any number of arrays
|
||||
* as long as their stride matches.
|
||||
*
|
||||
* \param stride: ``sizeof()`` each element,
|
||||
* \param stride: `sizeof()` each element,
|
||||
*
|
||||
* \note while a stride of ``1`` will always work,
|
||||
* \note while a stride of `1` will always work,
|
||||
* its less efficient since duplicate chunks of memory will be searched
|
||||
* at positions unaligned with the array data.
|
||||
*
|
||||
* \param chunk_count: Number of elements to split each chunk into.
|
||||
* - A small value increases the ability to de-duplicate chunks,
|
||||
* but adds overhead by increasing the number of chunks to look up when searching for duplicates,
|
||||
* as well as some overhead constructing the original array again, with more calls to ``memcpy``.
|
||||
* as well as some overhead constructing the original array again, with more calls to `memcpy`.
|
||||
* - Larger values reduce the *book keeping* overhead,
|
||||
* but increase the chance a small,
|
||||
* isolated change will cause a larger amount of data to be duplicated.
|
||||
|
@ -188,7 +188,7 @@ static int pointref_cmp_yx(const void *a_, const void *b_)
|
||||
* \param points: An array of 2D points.
|
||||
* \param n: The number of points in points.
|
||||
* \param r_points: An array of the convex hull vertex indices (max is n).
|
||||
* _must_ be allocated as ``n * 2`` because of how its used internally,
|
||||
* _must_ be allocated as `n * 2` because of how its used internally,
|
||||
* even though the final result will be no more than \a n in size.
|
||||
* \returns the number of points in r_points.
|
||||
*/
|
||||
|
@ -276,14 +276,14 @@ MINLINE void cpack_cpy_3ub(unsigned char r_col[3], const unsigned int pack)
|
||||
* https://en.wikipedia.org/wiki/Relative_luminance
|
||||
*
|
||||
* Real values are:
|
||||
* ``Y = 0.2126390059(R) + 0.7151686788(G) + 0.0721923154(B)``
|
||||
* `Y = 0.2126390059(R) + 0.7151686788(G) + 0.0721923154(B)`
|
||||
* according to: "Derivation of Basic Television Color Equations", RP 177-1993
|
||||
*
|
||||
* As this sums slightly above 1.0, the document recommends to use:
|
||||
* ``0.2126(R) + 0.7152(G) + 0.0722(B)``, as used here.
|
||||
* `0.2126(R) + 0.7152(G) + 0.0722(B)`, as used here.
|
||||
*
|
||||
* The high precision values are used to calculate the rounded byte weights so they add up to 255:
|
||||
* ``54(R) + 182(G) + 19(B)``
|
||||
* `54(R) + 182(G) + 19(B)`
|
||||
*/
|
||||
MINLINE float rgb_to_grayscale(const float rgb[3])
|
||||
{
|
||||
|
@ -165,7 +165,7 @@ float area_squared_poly_v3(const float verts[][3], unsigned int nr)
|
||||
/**
|
||||
* Scalar cross product of a 2d polygon.
|
||||
*
|
||||
* - equivalent to ``area * 2``
|
||||
* - equivalent to `area * 2`
|
||||
* - useful for checking polygon winding (a positive value is clockwise).
|
||||
*/
|
||||
float cross_poly_v2(const float verts[][2], unsigned int nr)
|
||||
@ -518,7 +518,7 @@ float dist_to_line_v3(const float p[3], const float l1[3], const float l2[3])
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if \a p is inside the 2x planes defined by ``(v1, v2, v3)``
|
||||
* Check if \a p is inside the 2x planes defined by `(v1, v2, v3)`
|
||||
* where the 3x points define 2x planes.
|
||||
*
|
||||
* \param axis_ref: used when v1,v2,v3 form a line and to check if the corner is concave/convex.
|
||||
@ -527,7 +527,7 @@ float dist_to_line_v3(const float p[3], const float l1[3], const float l2[3])
|
||||
* (it just defines the planes).
|
||||
*
|
||||
* \return the lowest squared distance to either of the planes.
|
||||
* where ``(return < 0.0)`` is outside.
|
||||
* where `(return < 0.0)` is outside.
|
||||
*
|
||||
* <pre>
|
||||
* v1
|
||||
@ -1421,7 +1421,7 @@ int isect_seg_seg_v2_lambda_mu_db(const double v1[2],
|
||||
* \return r_p1, r_p2: Intersection coordinates.
|
||||
*
|
||||
* \note The order of assignment for intersection points (\a r_p1, \a r_p2) is predictable,
|
||||
* based on the direction defined by ``l2 - l1``,
|
||||
* based on the direction defined by `l2 - l1`,
|
||||
* this direction compared with the normal of each point on the sphere:
|
||||
* \a r_p1 always has a >= 0.0 dot product.
|
||||
* \a r_p2 always has a <= 0.0 dot product.
|
||||
@ -3426,7 +3426,7 @@ float ray_point_factor_v3(const float p[3],
|
||||
|
||||
/**
|
||||
* A simplified version of #closest_to_line_v3
|
||||
* we only need to return the ``lambda``
|
||||
* we only need to return the `lambda`
|
||||
*
|
||||
* \param epsilon: avoid approaching divide-by-zero.
|
||||
* Passing a zero will just check for nonzero division.
|
||||
|
@ -272,7 +272,7 @@ MINLINE float shell_angle_to_dist(const float angle)
|
||||
return (UNLIKELY(angle < SMALL_NUMBER)) ? 1.0f : fabsf(1.0f / cosf(angle));
|
||||
}
|
||||
/**
|
||||
* equivalent to ``shell_angle_to_dist(angle_normalized_v3v3(a, b))``
|
||||
* Equivalent to `shell_angle_to_dist(angle_normalized_v3v3(a, b))`.
|
||||
*/
|
||||
MINLINE float shell_v3v3_normalized_to_dist(const float a[3], const float b[3])
|
||||
{
|
||||
@ -282,7 +282,7 @@ MINLINE float shell_v3v3_normalized_to_dist(const float a[3], const float b[3])
|
||||
return (UNLIKELY(angle_cos < SMALL_NUMBER)) ? 1.0f : (1.0f / angle_cos);
|
||||
}
|
||||
/**
|
||||
* equivalent to ``shell_angle_to_dist(angle_normalized_v2v2(a, b))``
|
||||
* Equivalent to `shell_angle_to_dist(angle_normalized_v2v2(a, b))`.
|
||||
*/
|
||||
MINLINE float shell_v2v2_normalized_to_dist(const float a[2], const float b[2])
|
||||
{
|
||||
@ -293,7 +293,7 @@ MINLINE float shell_v2v2_normalized_to_dist(const float a[2], const float b[2])
|
||||
}
|
||||
|
||||
/**
|
||||
* equivalent to ``shell_angle_to_dist(angle_normalized_v3v3(a, b) / 2)``
|
||||
* Equivalent to `shell_angle_to_dist(angle_normalized_v3v3(a, b) / 2)`.
|
||||
*/
|
||||
MINLINE float shell_v3v3_mid_normalized_to_dist(const float a[3], const float b[3])
|
||||
{
|
||||
@ -307,7 +307,7 @@ MINLINE float shell_v3v3_mid_normalized_to_dist(const float a[3], const float b[
|
||||
}
|
||||
|
||||
/**
|
||||
* equivalent to ``shell_angle_to_dist(angle_normalized_v2v2(a, b) / 2)``
|
||||
* Equivalent to `shell_angle_to_dist(angle_normalized_v2v2(a, b) / 2)`.
|
||||
*/
|
||||
MINLINE float shell_v2v2_mid_normalized_to_dist(const float a[2], const float b[2])
|
||||
{
|
||||
|
@ -1312,7 +1312,7 @@ MINLINE bool is_one_v3(const float v[3])
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Vector Comparison
|
||||
*
|
||||
* \note use ``value <= limit``, so a limit of zero doesn't fail on an exact match.
|
||||
* \note use `value <= limit`, so a limit of zero doesn't fail on an exact match.
|
||||
* \{ */
|
||||
|
||||
MINLINE bool equals_v2v2(const float v1[2], const float v2[2])
|
||||
|
@ -19,7 +19,7 @@
|
||||
* \brief Generic memory manipulation API.
|
||||
*
|
||||
* This is to extend on existing functions
|
||||
* such as ``memcpy`` & ``memcmp``.
|
||||
* such as `memcpy` & `memcmp`.
|
||||
*/
|
||||
#include <string.h>
|
||||
|
||||
|
@ -77,9 +77,9 @@ typedef signed char eSign;
|
||||
#ifdef USE_KDTREE
|
||||
/**
|
||||
* Spatial optimization for point-in-triangle intersection checks.
|
||||
* The simple version of this algorithm is ``O(n^2)`` complexity
|
||||
* The simple version of this algorithm is `O(n^2)` complexity
|
||||
* (every point needing to check the triangle defined by every other point),
|
||||
* Using a binary-tree reduces the complexity to ``O(n log n)``
|
||||
* Using a binary-tree reduces the complexity to `O(n log n)`
|
||||
* plus some overhead of creating the tree.
|
||||
*
|
||||
* This is a single purpose KDTree based on BLI_kdtree with some modifications
|
||||
@ -898,7 +898,7 @@ void BLI_polyfill_calc_arena(const float (*coords)[2],
|
||||
* \param coords_sign: Pass this when we know the sign in advance to avoid extra calculations.
|
||||
*
|
||||
* \param r_tris: This array is filled in with triangle indices in clockwise order.
|
||||
* The length of the array must be ``coords_tot - 2``.
|
||||
* The length of the array must be `coords_tot - 2`.
|
||||
* Indices are guaranteed to be assigned to unique triangles, with valid indices,
|
||||
* even in the case of degenerate input (self intersecting polygons, zero area ears... etc).
|
||||
*/
|
||||
|
@ -34,11 +34,11 @@
|
||||
* Otherwise #GHash should be used instead.
|
||||
*
|
||||
* #SmallHashEntry.key
|
||||
* - ``SMHASH_KEY_UNUSED`` means the key in the cell has not been initialized.
|
||||
* - `SMHASH_KEY_UNUSED` means the key in the cell has not been initialized.
|
||||
*
|
||||
* #SmallHashEntry.val
|
||||
* - ``SMHASH_CELL_UNUSED`` means this cell is inside a key series.
|
||||
* - ``SMHASH_CELL_FREE`` means this cell terminates a key series.
|
||||
* - `SMHASH_CELL_UNUSED` means this cell is inside a key series.
|
||||
* - `SMHASH_CELL_FREE` means this cell terminates a key series.
|
||||
*
|
||||
* Note that the values and keys are often pointers or index values,
|
||||
* use the maximum values to avoid real pointers colliding with magic numbers.
|
||||
|
@ -232,7 +232,7 @@ size_t BLI_vsnprintf(char *__restrict buffer,
|
||||
}
|
||||
|
||||
/**
|
||||
* A version of #BLI_vsnprintf that returns ``strlen(buffer)``
|
||||
* A version of #BLI_vsnprintf that returns `strlen(buffer)`
|
||||
*/
|
||||
size_t BLI_vsnprintf_rlen(char *__restrict buffer,
|
||||
size_t maxncpy,
|
||||
@ -278,7 +278,7 @@ size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict
|
||||
}
|
||||
|
||||
/**
|
||||
* A version of #BLI_snprintf that returns ``strlen(dst)``
|
||||
* A version of #BLI_snprintf that returns `strlen(dst)`
|
||||
*/
|
||||
size_t BLI_snprintf_rlen(char *__restrict dst, size_t maxncpy, const char *__restrict format, ...)
|
||||
{
|
||||
|
@ -39,7 +39,7 @@
|
||||
* Generate time-code/frame number string and store in \a str
|
||||
*
|
||||
* \param str: destination string
|
||||
* \param maxncpy: maximum number of characters to copy ``sizeof(str)``
|
||||
* \param maxncpy: maximum number of characters to copy `sizeof(str)`
|
||||
* \param brevity_level: special setting for #View2D grid drawing,
|
||||
* used to specify how detailed we need to be
|
||||
* \param time_seconds: time total time in seconds
|
||||
@ -199,7 +199,7 @@ size_t BLI_timecode_string_from_time(char *str,
|
||||
* Generate time string and store in \a str
|
||||
*
|
||||
* \param str: destination string
|
||||
* \param maxncpy: maximum number of characters to copy ``sizeof(str)``
|
||||
* \param maxncpy: maximum number of characters to copy `sizeof(str)`
|
||||
* \param time_seconds: time total time in seconds
|
||||
* \return length of \a str
|
||||
*/
|
||||
@ -229,7 +229,7 @@ size_t BLI_timecode_string_from_time_simple(char *str,
|
||||
* Generate time string and store in \a str
|
||||
*
|
||||
* \param str: destination string
|
||||
* \param maxncpy: maximum number of characters to copy ``sizeof(str)``
|
||||
* \param maxncpy: maximum number of characters to copy `sizeof(str)`
|
||||
* \param brevity_level: special setting for #View2D grid drawing,
|
||||
* used to specify how detailed we need to be
|
||||
* \param time_seconds: time total time in seconds
|
||||
|
@ -69,7 +69,7 @@
|
||||
* - write #TEST (#RenderInfo struct. 128x128 blend file preview is optional).
|
||||
* - write #GLOB (#FileGlobal struct) (some global vars).
|
||||
* - write #DNA1 (#SDNA struct)
|
||||
* - write #USER (#UserDef struct) if filename is ``~/.config/blender/X.XX/config/startup.blend``.
|
||||
* - write #USER (#UserDef struct) if filename is `~/.config/blender/X.XX/config/startup.blend`.
|
||||
*/
|
||||
|
||||
#include <fcntl.h>
|
||||
|
@ -37,7 +37,7 @@
|
||||
*
|
||||
* BMHeader flags should **never** be read or written to by bmesh operators (see Operators below).
|
||||
*
|
||||
* Access to header flags is done with ``BM_elem_flag_*()`` functions.
|
||||
* Access to header flags is done with `BM_elem_flag_*()` functions.
|
||||
* \subsection bm_faces Faces
|
||||
*
|
||||
* Faces in BMesh are stored as a circular linked list of loops. Loops store per-face-vertex data
|
||||
@ -55,7 +55,7 @@
|
||||
*
|
||||
* - BMLoop#v - pointer to the vertex associated with this loop.
|
||||
* - BMLoop#e - pointer to the edge associated with this loop,
|
||||
* between verts ``(loop->v, loop->next->v)``
|
||||
* between verts `(loop->v, loop->next->v)`
|
||||
* - BMLoop#f - pointer to the face associated with this loop.
|
||||
* \subsection bm_two_side_face 2-Sided Faces
|
||||
*
|
||||
@ -113,7 +113,7 @@
|
||||
*
|
||||
* These slots are identified by name, using strings.
|
||||
*
|
||||
* Access to slots is done with ``BMO_slot_***()`` functions.
|
||||
* Access to slots is done with `BMO_slot_***()` functions.
|
||||
* \subsection bm_tool_flags Tool Flags
|
||||
*
|
||||
* The BMesh API provides a set of flags for faces, edges and vertices,
|
||||
@ -126,7 +126,7 @@
|
||||
* These flags should not be confused with header flags, which are used to store persistent flags
|
||||
* (e.g. selection, hide status, etc).
|
||||
*
|
||||
* Access to tool flags is done with ``BMO_elem_flag_***()`` functions.
|
||||
* Access to tool flags is done with `BMO_elem_flag_***()` functions.
|
||||
*
|
||||
* \warning Operators are **never** allowed to read or write to header flags.
|
||||
* They act entirely on the data inside their input slots.
|
||||
@ -162,14 +162,14 @@
|
||||
*
|
||||
* These conventions should be used throughout the bmesh module.
|
||||
*
|
||||
* - ``bmesh_kernel_*()`` - Low level API, for primitive functions that others are built ontop of.
|
||||
* - ``bmesh_***()`` - Low level API function.
|
||||
* - ``bm_***()`` - 'static' functions, not a part of the API at all,
|
||||
* - `bmesh_kernel_*()` - Low level API, for primitive functions that others are built ontop of.
|
||||
* - `bmesh_***()` - Low level API function.
|
||||
* - `bm_***()` - 'static' functions, not a part of the API at all,
|
||||
* but use prefix since they operate on BMesh data.
|
||||
* - ``BM_***()`` - High level BMesh API function for use anywhere.
|
||||
* - ``BMO_***()`` - High level operator API function for use anywhere.
|
||||
* - ``bmo_***()`` - Low level / internal operator API functions.
|
||||
* - ``_bm_***()`` - Functions which are called via macros only.
|
||||
* - `BM_***()` - High level BMesh API function for use anywhere.
|
||||
* - `BMO_***()` - High level operator API function for use anywhere.
|
||||
* - `bmo_***()` - Low level / internal operator API functions.
|
||||
* - `_bm_***()` - Functions which are called via macros only.
|
||||
*
|
||||
* \section bm_todo BMesh TODO's
|
||||
*
|
||||
|
@ -245,7 +245,7 @@ static BMOpDefine bmo_region_extend_def = {
|
||||
* Edge Rotate.
|
||||
*
|
||||
* Rotates edges topologically. Also known as "spin edge" to some people.
|
||||
* Simple example: ``[/] becomes [|] then [\]``.
|
||||
* Simple example: `[/] becomes [|] then [\]`.
|
||||
*/
|
||||
static BMOpDefine bmo_rotate_edges_def = {
|
||||
"rotate_edges",
|
||||
|
@ -316,7 +316,7 @@ float BM_face_calc_perimeter_with_mat3(const BMFace *f, const float mat3[3][3])
|
||||
/**
|
||||
* Utility function to calculate the edge which is most different from the other two.
|
||||
*
|
||||
* \return The first edge index, where the second vertex is ``(index + 1) % 3``.
|
||||
* \return The first edge index, where the second vertex is `(index + 1) % 3`.
|
||||
*/
|
||||
static int bm_vert_tri_find_unique_edge(BMVert *verts[3])
|
||||
{
|
||||
|
@ -766,7 +766,7 @@ bool BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb)
|
||||
}
|
||||
|
||||
/**
|
||||
* Fast alternative to ``(BM_vert_edge_count(v) == 2)``
|
||||
* Fast alternative to `(BM_vert_edge_count(v) == 2)`.
|
||||
*/
|
||||
bool BM_vert_is_edge_pair(const BMVert *v)
|
||||
{
|
||||
@ -779,7 +779,7 @@ bool BM_vert_is_edge_pair(const BMVert *v)
|
||||
}
|
||||
|
||||
/**
|
||||
* Fast alternative to ``(BM_vert_edge_count(v) == 2)``
|
||||
* Fast alternative to `(BM_vert_edge_count(v) == 2)`
|
||||
* that checks both edges connect to the same faces.
|
||||
*/
|
||||
bool BM_vert_is_edge_pair_manifold(const BMVert *v)
|
||||
@ -896,7 +896,7 @@ int BM_vert_face_count_at_most(const BMVert *v, int count_max)
|
||||
/**
|
||||
* Return true if the vertex is connected to _any_ faces.
|
||||
*
|
||||
* same as ``BM_vert_face_count(v) != 0`` or ``BM_vert_find_first_loop(v) == NULL``
|
||||
* same as `BM_vert_face_count(v) != 0` or `BM_vert_find_first_loop(v) == NULL`.
|
||||
*/
|
||||
bool BM_vert_face_check(const BMVert *v)
|
||||
{
|
||||
|
@ -592,7 +592,7 @@ int bmesh_radial_facevert_count_at_most(const BMLoop *l, const BMVert *v, const
|
||||
/**
|
||||
* \brief RADIAL CHECK FACE VERT
|
||||
*
|
||||
* Quicker check for ``bmesh_radial_facevert_count(...) != 0``
|
||||
* Quicker check for `bmesh_radial_facevert_count(...) != 0`.
|
||||
*/
|
||||
bool bmesh_radial_facevert_check(const BMLoop *l, const BMVert *v)
|
||||
{
|
||||
|
@ -46,14 +46,14 @@ void SunBeamsOperation::initExecution()
|
||||
* (u,v) is used to designate sector space coordinates
|
||||
*
|
||||
* For a target point (x,y) the sector should be chosen such that
|
||||
* ``u >= v >= 0``
|
||||
* `u >= v >= 0`
|
||||
* This removes the need to handle all sorts of special cases.
|
||||
*
|
||||
* Template parameters:
|
||||
* fxu : buffer increment in x for sector u+1
|
||||
* fxv : buffer increment in x for sector v+1
|
||||
* fyu : buffer increment in y for sector u+1
|
||||
* fyv : buffer increment in y for sector v+1
|
||||
* \param fxu: buffer increment in x for sector `u + 1`.
|
||||
* \param fxv: buffer increment in x for sector `v + 1`.
|
||||
* \param fyu: buffer increment in y for sector `u + 1`.
|
||||
* \param fyv: buffer increment in y for sector `v + 1`.
|
||||
*/
|
||||
template<int fxu, int fxv, int fyu, int fyv> struct BufferLineAccumulator {
|
||||
|
||||
|
@ -123,7 +123,7 @@ ListBase *ED_animcontext_get_markers(const bAnimContext *ac)
|
||||
* so don't assume anything.
|
||||
* \param scene: Current scene (for getting current frame)
|
||||
* \param mode: (TfmMode) transform mode that this transform is for
|
||||
* \param value: From the transform code, this is ``t->vec[0]``
|
||||
* \param value: From the transform code, this is `t->vec[0]`
|
||||
* (which is delta transform for grab/extend, and scale factor for scale)
|
||||
* \param side: (B/L/R) for 'extend' functionality, which side of current frame to use
|
||||
*/
|
||||
|
@ -3066,7 +3066,7 @@ static bool ui_textedit_set_cursor_pos_foreach_glyph(const char *UNUSED(str),
|
||||
/**
|
||||
* \param x: Screen space cursor location - #wmEvent.x
|
||||
*
|
||||
* \note ``but->block->aspect`` is used here, so drawing button style is getting scaled too.
|
||||
* \note `but->block->aspect` is used here, so drawing button style is getting scaled too.
|
||||
*/
|
||||
static void ui_textedit_set_cursor_pos(uiBut *but, uiHandleButtonData *data, const float x)
|
||||
{
|
||||
|
@ -1914,7 +1914,7 @@ float UI_view2d_scale_get_y(const View2D *v2d)
|
||||
return BLI_rcti_size_y(&v2d->mask) / BLI_rctf_size_y(&v2d->cur);
|
||||
}
|
||||
/**
|
||||
* Same as ``UI_view2d_scale_get() - 1.0f / x, y``
|
||||
* Same as `UI_view2d_scale_get() - 1.0f / x, y`.
|
||||
*/
|
||||
void UI_view2d_scale_get_inverse(const View2D *v2d, float *r_x, float *r_y)
|
||||
{
|
||||
|
@ -375,7 +375,7 @@ typedef struct ProjPaintState {
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* Vars shared between multiple views (keep last) */
|
||||
/**
|
||||
* This data is owned by ``ProjStrokeHandle.ps_views[0]``,
|
||||
* This data is owned by `ProjStrokeHandle.ps_views[0]`,
|
||||
* all other views re-use the data.
|
||||
*/
|
||||
|
||||
|
@ -24,7 +24,7 @@
|
||||
* Typical view-control usage:
|
||||
*
|
||||
* - Acquire a view-control (#ED_view3d_cameracontrol_acquire).
|
||||
* - Modify ``rv3d->ofs``, ``rv3d->viewquat``.
|
||||
* - Modify `rv3d->ofs`, `rv3d->viewquat`.
|
||||
* - Update the view data (#ED_view3d_cameracontrol_acquire) -
|
||||
* within a loop which draws the viewport.
|
||||
* - Finish and release the view-control (#ED_view3d_cameracontrol_release),
|
||||
@ -32,8 +32,8 @@
|
||||
*
|
||||
* Notes:
|
||||
*
|
||||
* - when acquiring ``rv3d->dist`` is set to zero
|
||||
* (so ``rv3d->ofs`` is always the view-point)
|
||||
* - when acquiring `rv3d->dist` is set to zero
|
||||
* (so `rv3d->ofs` is always the view-point)
|
||||
* - updating can optionally keyframe the camera object.
|
||||
*/
|
||||
|
||||
@ -244,7 +244,7 @@ static bool object_apply_mat4_with_protect(Object *ob,
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates cameras from the ``rv3d`` values, optionally auto-keyframing.
|
||||
* Updates cameras from the `rv3d` values, optionally auto-keyframing.
|
||||
*/
|
||||
void ED_view3d_cameracontrol_update(View3DCameraControl *vctrl,
|
||||
/* args for keyframing */
|
||||
|
@ -506,8 +506,8 @@ void ED_view3d_lock_clear(View3D *v3d)
|
||||
/**
|
||||
* For viewport operators that exit camera perspective.
|
||||
*
|
||||
* \note This differs from simply setting ``rv3d->persp = persp`` because it
|
||||
* sets the ``ofs`` and ``dist`` values of the viewport so it matches the camera,
|
||||
* \note This differs from simply setting `rv3d->persp = persp` because it
|
||||
* sets the `ofs` and `dist` values of the viewport so it matches the camera,
|
||||
* otherwise switching out of camera view may jump to a different part of the scene.
|
||||
*/
|
||||
void ED_view3d_persp_switch_from_camera(const Depsgraph *depsgraph,
|
||||
|
@ -1142,7 +1142,7 @@ static void raycast_obj_fn(SnapObjectContext *sctx,
|
||||
* \param r_loc: Hit location.
|
||||
* \param r_no: Hit normal (optional).
|
||||
* \param r_index: Hit index or -1 when no valid index is found.
|
||||
* (currently only set to the polygon index when using ``snap_to == SCE_SNAP_MODE_FACE``).
|
||||
* (currently only set to the polygon index when using `snap_to == SCE_SNAP_MODE_FACE`).
|
||||
* \param r_ob: Hit object.
|
||||
* \param r_obmat: Object matrix (may not be #Object.obmat with dupli-instances).
|
||||
* \param r_hit_list: List of #SnapObjectHitDepth (caller must free).
|
||||
@ -2793,7 +2793,7 @@ static void snap_obj_fn(SnapObjectContext *sctx,
|
||||
* \param r_loc: Hit location.
|
||||
* \param r_no: Hit normal (optional).
|
||||
* \param r_index: Hit index or -1 when no valid index is found.
|
||||
* (currently only set to the polygon index when using ``snap_to == SCE_SNAP_MODE_FACE``).
|
||||
* (currently only set to the polygon index when using `snap_to == SCE_SNAP_MODE_FACE`).
|
||||
* \param r_ob: Hit object.
|
||||
* \param r_obmat: Object matrix (may not be #Object.obmat with dupli-instances).
|
||||
*/
|
||||
|
@ -56,7 +56,7 @@
|
||||
*
|
||||
* Ignored structs can only be referred to from non-ignored structs
|
||||
* when referred to as a pointer (where they're usually allocated
|
||||
* and cleared in ``readfile.c``).
|
||||
* and cleared in `readfile.c`).
|
||||
*
|
||||
* - %Path to the header files
|
||||
*
|
||||
|
@ -84,8 +84,8 @@
|
||||
* **Remember to read/write integer and short aligned!**
|
||||
*
|
||||
* While writing a file, the names of a struct is indicated with a type number,
|
||||
* to be found with: ``type = DNA_struct_find_nr(SDNA *, const char *)``
|
||||
* The value of ``type`` corresponds with the index within the structs array
|
||||
* to be found with: `type = DNA_struct_find_nr(SDNA *, const char *)`
|
||||
* The value of `type` corresponds with the index within the structs array
|
||||
*
|
||||
* For the moment: the complete DNA file is included in a .blend file. For
|
||||
* the future we can think of smarter methods, like only included the used
|
||||
@ -101,7 +101,7 @@
|
||||
* - Change of a pointer type: when the name doesn't change the contents is copied.
|
||||
*
|
||||
* NOT YET:
|
||||
* - array (``vec[3]``) to float struct (``vec3f``).
|
||||
* - array (`vec[3]`) to float struct (`vec3f`).
|
||||
*
|
||||
* DONE:
|
||||
* - Endian compatibility.
|
||||
|
@ -5998,7 +5998,7 @@ static void rna_path_array_multi_string_from_flat_index(PointerRNA *ptr,
|
||||
|
||||
/**
|
||||
* \param index_dim: The dimension to show, 0 disables. 1 for 1d array, 2 for 2d. etc.
|
||||
* \param index: The *flattened* index to use when \a ``index_dim > 0``,
|
||||
* \param index: The *flattened* index to use when \a `index_dim > 0`,
|
||||
* this is expanded when used with multi-dimensional arrays.
|
||||
*/
|
||||
char *RNA_path_from_ID_to_property_index(PointerRNA *ptr,
|
||||
|
@ -1825,7 +1825,7 @@ static void rna_KeyMapItem_update(Main *UNUSED(bmain), Scene *UNUSED(scene), Poi
|
||||
#else /* RNA_RUNTIME */
|
||||
|
||||
/**
|
||||
* expose ``Operator.options`` as its own type so we can control each flags use
|
||||
* expose `Operator.options` as its own type so we can control each flags use
|
||||
* (some are read-only).
|
||||
*/
|
||||
static void rna_def_operator_options_runtime(BlenderRNA *brna)
|
||||
|
@ -257,10 +257,10 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
|
||||
generate_vert_coordinates(mesh, ob, ob_target, enmd->offset, num_verts, cos, size);
|
||||
|
||||
/**
|
||||
* size gives us our spheroid coefficients ``(A, B, C)``.
|
||||
* size gives us our spheroid coefficients `(A, B, C)`.
|
||||
* Then, we want to find out for each vert its (a, b, c) triple (proportional to (A, B, C) one).
|
||||
*
|
||||
* Ellipsoid basic equation: ``(x^2/a^2) + (y^2/b^2) + (z^2/c^2) = 1.``
|
||||
* Ellipsoid basic equation: `(x^2/a^2) + (y^2/b^2) + (z^2/c^2) = 1`.
|
||||
* Since we want to find (a, b, c) matching this equation and proportional to (A, B, C),
|
||||
* we can do:
|
||||
* <pre>
|
||||
|
@ -525,7 +525,7 @@ PyObject *PyC_FrozenSetFromStrings(const char **strings)
|
||||
*
|
||||
* Implementation - we can't actually prepend the existing exception,
|
||||
* because it could have _any_ arguments given to it, so instead we get its
|
||||
* ``__str__`` output and raise our own exception including it.
|
||||
* `__str__` output and raise our own exception including it.
|
||||
*/
|
||||
PyObject *PyC_Err_Format_Prefix(PyObject *exception_type_prefix, const char *format, ...)
|
||||
{
|
||||
|
@ -17,8 +17,8 @@
|
||||
/** \file
|
||||
* \ingroup bpygpu
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -20,8 +20,8 @@
|
||||
* Experimental Python API, not considered public yet (called '_gpu'),
|
||||
* we may re-expose as public later.
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -19,11 +19,11 @@
|
||||
/** \file
|
||||
* \ingroup bpygpu
|
||||
*
|
||||
* This file defines the offscreen functionalities of the 'gpu' module
|
||||
* This file defines the off-screen functionalities of the 'gpu' module
|
||||
* used for off-screen OpenGL rendering.
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -19,8 +19,8 @@
|
||||
*
|
||||
* This file defines the gpu.state API.
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -17,8 +17,8 @@
|
||||
/** \file
|
||||
* \ingroup bpygpu
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -17,8 +17,8 @@
|
||||
/** \file
|
||||
* \ingroup bpygpu
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -20,8 +20,8 @@
|
||||
* This file defines the framebuffer functionalities of the 'gpu' module
|
||||
* used for off-screen OpenGL rendering.
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -22,8 +22,8 @@
|
||||
* \warning While these functions attempt to ensure correct stack usage.
|
||||
* Mixing Python and C functions may still crash on invalid use.
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -22,8 +22,8 @@
|
||||
* This file defines the offscreen functionalities of the 'gpu' module
|
||||
* used for off-screen OpenGL rendering.
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -17,8 +17,8 @@
|
||||
/** \file
|
||||
* \ingroup bpygpu
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -22,8 +22,8 @@
|
||||
* \note Currently only used for gizmo selection,
|
||||
* will need to add begin/end and a way to access the hits.
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -17,8 +17,8 @@
|
||||
/** \file
|
||||
* \ingroup bpygpu
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -19,8 +19,8 @@
|
||||
*
|
||||
* This file defines the gpu.state API.
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -19,8 +19,8 @@
|
||||
*
|
||||
* This file defines the texture functionalities of the 'gpu' module
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -17,8 +17,8 @@
|
||||
/** \file
|
||||
* \ingroup bpygpu
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -19,8 +19,8 @@
|
||||
*
|
||||
* This file defines the uniform buffer functionalities of the 'gpu' module
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -17,8 +17,8 @@
|
||||
/** \file
|
||||
* \ingroup bpygpu
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -17,8 +17,8 @@
|
||||
/** \file
|
||||
* \ingroup bpygpu
|
||||
*
|
||||
* - Use ``bpygpu_`` for local API.
|
||||
* - Use ``BPyGPU`` for public API.
|
||||
* - Use `bpygpu_` for local API.
|
||||
* - Use `BPyGPU` for public API.
|
||||
*/
|
||||
|
||||
#include <Python.h>
|
||||
|
@ -67,7 +67,7 @@ static const char *bpyunits_ucategorie_items[] = {
|
||||
/**
|
||||
* These fields are just empty placeholders, actual values get set in initializations functions.
|
||||
* This allows us to avoid many handwriting, and above all,
|
||||
* to keep all systems/categories definition stuff in ``BKE_unit.h``.
|
||||
* to keep all systems/categories definition stuff in `BKE_unit.h`.
|
||||
*/
|
||||
static PyStructSequence_Field bpyunits_systems_fields[ARRAY_SIZE(bpyunits_usystem_items)];
|
||||
static PyStructSequence_Field bpyunits_categories_fields[ARRAY_SIZE(bpyunits_ucategorie_items)];
|
||||
|
@ -78,7 +78,7 @@ static int mathutils_array_parse_fast(float *array,
|
||||
}
|
||||
|
||||
/**
|
||||
* helper function that returns a Python ``__hash__``.
|
||||
* helper function that returns a Python `__hash__`.
|
||||
*
|
||||
* \note consistent with the equivalent tuple of floats (CPython's 'tuplehash')
|
||||
*/
|
||||
|
@ -1174,7 +1174,7 @@ static void matrix_invert_with_det_n_internal(float *mat_dst,
|
||||
}
|
||||
|
||||
/**
|
||||
* \param r_mat: can be from ``self->matrix`` or not.
|
||||
* \param r_mat: can be from `self->matrix` or not.
|
||||
*/
|
||||
static bool matrix_invert_internal(const MatrixObject *self, float *r_mat)
|
||||
{
|
||||
@ -1191,8 +1191,8 @@ static bool matrix_invert_internal(const MatrixObject *self, float *r_mat)
|
||||
}
|
||||
|
||||
/**
|
||||
* Similar to ``matrix_invert_internal`` but should never error.
|
||||
* \param r_mat: can be from ``self->matrix`` or not.
|
||||
* Similar to `matrix_invert_internal` but should never error.
|
||||
* \param r_mat: can be from `self->matrix` or not.
|
||||
*/
|
||||
static void matrix_invert_safe_internal(const MatrixObject *self, float *r_mat)
|
||||
{
|
||||
|
@ -26,7 +26,7 @@
|
||||
* The Bake API is fully implemented with Python rna functions.
|
||||
* The operator expects/call a function:
|
||||
*
|
||||
* ``def bake(scene, object, pass_type, object_id, pixel_array, num_pixels, depth, result)``
|
||||
* `def bake(scene, object, pass_type, object_id, pixel_array, num_pixels, depth, result)`
|
||||
* - scene: current scene (Python object)
|
||||
* - object: object to render (Python object)
|
||||
* - pass_type: pass to render (string, e.g., "COMBINED", "AO", "NORMAL", ...)
|
||||
@ -53,10 +53,10 @@
|
||||
* \endcode
|
||||
*
|
||||
* In python you have access to:
|
||||
* - ``primitive_id``, ``object_id``, ``uv``, ``du_dx``, ``du_dy``, ``next``
|
||||
* - ``next()`` is a function that returns the next #BakePixel in the array.
|
||||
* - `primitive_id`, `object_id`, `uv`, `du_dx`, `du_dy`, `next`.
|
||||
* - `next()` is a function that returns the next #BakePixel in the array.
|
||||
*
|
||||
* \note Pixels that should not be baked have ``primitive_id == -1``
|
||||
* \note Pixels that should not be baked have `primitive_id == -1`.
|
||||
*
|
||||
* For a complete implementation example look at the Cycles Bake commit.
|
||||
*/
|
||||
|
@ -91,7 +91,7 @@ enum {
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name wmGizmoMap Selection Array API
|
||||
*
|
||||
* Just handle ``wm_gizmomap_select_array_*``, not flags or callbacks.
|
||||
* Just handle `wm_gizmomap_select_array_*`, not flags or callbacks.
|
||||
*
|
||||
* \{ */
|
||||
|
||||
|
@ -987,7 +987,7 @@ const char *WM_init_state_app_template_get(void)
|
||||
* or called for 'New File' both startup.blend and userpref.blend are checked.
|
||||
*
|
||||
* \param use_factory_settings:
|
||||
* Ignore on-disk startup file, use bundled ``datatoc_startup_blend`` instead.
|
||||
* Ignore on-disk startup file, use bundled `datatoc_startup_blend` instead.
|
||||
* Used for "Restore Factory Settings".
|
||||
*
|
||||
* \param use_userdef: Load factory settings as well as startup file.
|
||||
|
@ -23,8 +23,8 @@
|
||||
* Default operator callbacks for use with gestures (border/circle/lasso/straightline).
|
||||
* Operators themselves are defined elsewhere.
|
||||
*
|
||||
* - Keymaps are in ``wm_operators.c``.
|
||||
* - Property definitions are in ``wm_operator_props.c``.
|
||||
* - Keymaps are in `wm_operators.c`.
|
||||
* - Property definitions are in `wm_operator_props.c`.
|
||||
*/
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
Loading…
Reference in New Issue
Block a user