Commit: 5ad6ab98cd369036e5469995c44825c182c59684
Author: Lukas Tönne
Date: Tue Jul 5 10:47:24 2016 +0200
Branches: strand_gpu
https://developer.blender.org/rB5ad6ab98cd369036e5469995c44825c182c59684
Merge branch 'strand_editmode' into strand_gpu_editmode
===================================================================
===================================================================
diff --cc source/blender/blenkernel/intern/mesh_sample.c
index 07ddc42,afc4959..5842a39
--- a/source/blender/blenkernel/intern/mesh_sample.c
+++ b/source/blender/blenkernel/intern/mesh_sample.c
@@@ -682,3 -687,92 +687,93 @@@ bool BKE_mesh_sample_generate(MeshSampl
{
return gen->make_sample(gen, sample);
}
++
+ /* ==== Utilities ==== */
+
+ #include "DNA_particle_types.h"
+
+ #include "BKE_bvhutils.h"
+ #include "BKE_particle.h"
+
+ bool BKE_mesh_sample_from_particle(MeshSample *sample, ParticleSystem *psys,
DerivedMesh *dm, ParticleData *pa)
+ {
+ MVert *mverts;
+ MFace *mface;
+ float mapfw[4];
+ int mapindex;
+ float *co1 = NULL, *co2 = NULL, *co3 = NULL, *co4 = NULL;
+ float vec[3];
+ float w[4];
+
+ if (!psys_get_index_on_dm(psys, dm, pa, &mapindex, mapfw))
+ return false;
+
+ mface = dm->getTessFaceData(dm, mapindex, CD_MFACE);
+ mverts = dm->getVertDataArray(dm, CD_MVERT);
+
+ co1 = mverts[mface->v1].co;
+ co2 = mverts[mface->v2].co;
+ co3 = mverts[mface->v3].co;
+
+ if (mface->v4) {
+ co4 = mverts[mface->v4].co;
+
+ interp_v3_v3v3v3v3(vec, co1, co2, co3, co4, mapfw);
+ }
+ else {
+ interp_v3_v3v3v3(vec, co1, co2, co3, mapfw);
+ }
+
+ /* test both triangles of the face */
+ interp_weights_face_v3(w, co1, co2, co3, NULL, vec);
+ if (w[0] <= 1.0f && w[1] <= 1.0f && w[2] <= 1.0f) {
+ sample->orig_verts[0] = mface->v1;
+ sample->orig_verts[1] = mface->v2;
+ sample->orig_verts[2] = mface->v3;
+
+ copy_v3_v3(sample->orig_weights, w);
+ return true;
+ }
+ else if (mface->v4) {
+ interp_weights_face_v3(w, co3, co4, co1, NULL, vec);
+ sample->orig_verts[0] = mface->v3;
+ sample->orig_verts[1] = mface->v4;
+ sample->orig_verts[2] = mface->v1;
+
+ copy_v3_v3(sample->orig_weights, w);
+ return true;
+ }
+ else
+ return false;
+ }
+
+ bool BKE_mesh_sample_to_particle(MeshSample *sample, ParticleSystem
*UNUSED(psys), DerivedMesh *dm, BVHTreeFromMesh *bvhtree, ParticleData *pa)
+ {
+ BVHTreeNearest nearest;
+ float vec[3], nor[3], tang[3];
+
+ BKE_mesh_sample_eval(dm, sample, vec, nor, tang);
+
+ nearest.index = -1;
+ nearest.dist_sq = FLT_MAX;
+ BLI_bvhtree_find_nearest(bvhtree->tree, vec, &nearest,
bvhtree->nearest_callback, bvhtree);
+ if (nearest.index >= 0) {
+ MFace *mface = dm->getTessFaceData(dm, nearest.index, CD_MFACE);
+ MVert *mverts = dm->getVertDataArray(dm, CD_MVERT);
+
+ float *co1 = mverts[mface->v1].co;
+ float *co2 = mverts[mface->v2].co;
+ float *co3 = mverts[mface->v3].co;
+ float *co4 = mface->v4 ? mverts[mface->v4].co : NULL;
+
+ pa->num = nearest.index;
+ pa->num_dmcache = DMCACHE_NOTFOUND;
+
+ interp_weights_face_v3(pa->fuv, co1, co2, co3, co4, vec);
+ pa->foffset = 0.0f; /* XXX any sensible way to reconstruct
this? */
+
+ return true;
+ }
+ else
+ return false;
+ }
diff --cc source/blender/editors/space_view3d/drawstrands.c
index f03ccae,dd37e41..7161de7
--- a/source/blender/editors/space_view3d/drawstrands.c
+++ b/source/blender/editors/space_view3d/drawstrands.c
@@@ -33,60 -29,354 +33,407 @@@
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_strand_types.h"
#include "DNA_view3d_types.h"
+#include "BLI_utildefines.h"
+#include "BLI_math.h"
+
+ #include "BKE_editstrands.h"
+#include "BKE_DerivedMesh.h"
+ #include "BKE_main.h"
+#include "BKE_strands.h"
+ #include "bmesh.h"
+
+#include "BIF_gl.h"
++#include "BIF_glutil.h"
+
+#include "GPU_buffers.h"
+#include "GPU_debug.h"
++#include "GPU_draw.h"
++#include "GPU_extensions.h"
++#include "GPU_select.h"
+#include "GPU_shader.h"
+#include "GPU_strands.h"
+
+ #include "ED_screen.h"
+ #include "ED_types.h"
+
+ #include "UI_resources.h"
+ #include "UI_interface_icons.h"
+
-#include "BIF_gl.h"
-#include "BIF_glutil.h"
+#include "view3d_intern.h" // own include
-#include "GPU_draw.h"
-#include "GPU_extensions.h"
-#include "GPU_select.h"
+void draw_strands(Strands *strands, StrandData *data, Object *ob,
RegionView3D *rv3d,
+ bool show_controls, bool show_strands)
+{
+ GPUStrandsShader *gpu_shader = GPU_strand_shader_get(strands);
+
+ if (show_controls) {
+ GPU_strands_setup_edges(data);
+ GPUDrawStrands *gds = data->gpu_buffer;
+ if (gds->control_points && gds->control_edges) {
+ GPU_buffer_draw_elements(gds->control_edges, GL_LINES,
0,
+ (gds->totverts -
gds->totcurves) * 2);
+ }
+ GPU_buffers_unbind();
+ }
+
+ if (show_strands) {
+ GPU_strand_shader_bind_uniforms(gpu_shader, ob->obmat,
rv3d->viewmat);
+ GPU_strand_shader_bind(gpu_shader, rv3d->viewmat,
rv3d->viewinv);
+
+ GPU_strands_setup_roots(data);
+ GPUDrawStrands *gds = data->gpu_buffer;
+ if (gds->root_points) {
+ struct GPUAttrib *attrib;
+ int num_attrib;
+ GPU_strand_shader_get_attributes(strands->gpu_shader,
&attrib, &num_attrib);
+
+ int elemsize = GPU_attrib_element_size(attrib,
num_attrib);
+ GPU_interleaved_attrib_setup(gds->root_points, attrib,
num_attrib, elemsize, false);
+
+ glDrawArrays(GL_POINTS, 0, gds->totroots * elemsize);
+
+ GPU_interleaved_attrib_unbind();
+ }
+ GPU_strands_buffer_unbind();
+
+ GPU_strand_shader_unbind(gpu_shader);
+ }
+}
+
-#include "view3d_intern.h"
++/*************************/
++/*** Edit Mode Drawing ***/
+
+ typedef enum StrandsShadeMode {
+ STRANDS_SHADE_FLAT,
+ STRANDS_SHADE_HAIR,
+ } StrandsShadeMode;
+
+ typedef struct StrandsDrawInfo {
+ bool has_zbuf;
+ bool use_zbuf_select;
+
+ StrandsShadeMode shade_mode;
+ int select_mode;
+
+ float col_base[4];
+ float col_select[4];
+ } StrandsDrawInfo;
+
+ BLI_INLINE bool strands_use_normals(const StrandsDrawInfo *info)
+ {
+ return ELEM(info->shade_mode, STRANDS_SHADE_HAIR);
+ }
+
+ static void init_draw_info(StrandsDrawInfo *info, View3D *v3d,
+ StrandsShadeMode shade_mode, int select_mode)
+ {
+ info->has_zbuf = v3d->zbuf;
+ info->use_zbuf_select = (v3d->flag & V3D_ZBUF_SELECT);
+
+ info->shade_mode = shade_mode;
+ info->select_mode = select_mode;
+
+ /* get selection theme colors */
+ UI_GetThemeColor4fv(TH_VERTEX, info->col_base);
+ UI_GetThemeColor4fv(TH_VERTEX_SELECT, info->col_select);
+ }
+
+ static void set_opengl_state_strands(const StrandsDrawInfo *info)
+ {
+ if (!info->use_zbuf_select)
+ glDisable(GL_DEPTH_TEST);
+ glEnable(GL_BLEND);
+
+ if (ELEM(info->shade_mode, STRANDS_SHADE_HAIR)) {
+ glEnable(GL_LIGHTING);
+ glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
+ glEnable(GL_COLOR_MATERIAL);
+ glShadeModel(GL_SMOOTH);
+ }
+ else {
+ glDisable(GL_LIGHTING);
+ }
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ if (strands_use_normals(info))
+ glEnableClientState(GL_NORMAL_ARRAY);
+ }
+
+ static void set_opengl_state_dots(const StrandsDrawInfo *info)
+ {
+ if (!info->use_zbuf_select)
+ glDisable(GL_DEPTH_TEST);
+ glEnable(GL_BLEND);
+
+ glDisable(GL_LIGHTING);
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glPointSize(3.0);
+ }
+
+ static void restore_opengl_state(const StrandsDrawInfo *info)
+ {
+ glDisableClientState(GL_NORMAL_ARRAY);
+ glDisableClientState(GL_VERTEX_ARRAY);
+
+ glDisable(GL_BLEND);
+ glDisable(GL_LIGHTING);
+ glDisable(GL_COLOR_MATERIAL);
+ glShadeModel(GL_FLAT);
+ if (info->has_zbuf)
+ glEnable(GL_DEPTH_TEST);
+ glLineWidth(1.0f);
+ glPointSize(1.0);
+ }
+
+ /* -------------------------------------------------------------------------
*/
+ /* strands */
+
+ static void setup_gpu_buffers_strands(BMEditStrands *edit, const
StrandsDrawInfo *info)
+ {
+ const size_t size_v3 = sizeof(float) * 3;
+ const size_t size_vertex = (strands_use_normals(info) ? 2*size_v3 :
size_v3);
+ BMesh *bm = edit->base.bm;
+
+ // int totstrands = BM_strands_count(edit->bm);
+ int totvert = bm->totvert;
+ int totedge = bm->totedge;
+
+ if (!edit->vertex_glbuf)
+ glGenBuffers(1, &edit->vertex_glbuf);
+ if (!edit->elem_glbuf)
+ glGenBuffers(1, &edit->elem_glbuf);
+
+ glBindBuffer(GL_ARRAY_BUFFER, edit->vertex_glbuf);
+ glBufferData(GL_ARRAY_BUFFER, size_vertex * totvert, NULL,
GL_DYNAMIC_DRAW);
+
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, edit->elem_glbuf);
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * totedge *
2, NULL, GL_DYNAMIC_DRAW);
+
+ glVertexPointer(3, GL_FLOAT, size_vertex, NULL);
+ if (strands_use_normals(info))
+ glNormalPointer(GL_FLOAT, size_vertex, (GLubyte *)NULL +
size_v3);
+ }
+
+ static void unbind_gpu_buffers_strands(void)
+ {
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+ }
+
+ static int write_gpu_buffers_strands(BMEditStrands *edit, const
StrandsDrawInfo *info)
+ {
+ const size_t size_v3 = sizeof(float) * 3;
+ const size_t size_vertex = (strands_use_normals(info) ? 2*size_v3 :
size_v3);
+ BMesh *bm = edit->base.bm;
+
+ GLubyte *vertex_data;
+ unsigned int *elem_data;
+ BMVert *root, *v, *vprev;
+ BMIter iter, iter_strand;
+ int index, indexprev, index_edge;
+ int k;
+
+ vertex_data = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
+ elem_data = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
+ if (!vertex_data || !elem_data)
+ return 0;
+
+ BM_mesh_elem_index_ensure(bm, BM_VERT);
+
+ index_edge = 0;
+ BM_ITER_STRANDS(root, &iter, bm, BM_STRANDS_OF_MESH) {
+ BM_ITER_STRANDS_ELEM_INDEX(v, &iter_strand, root,
BM_VERTS_OF_STRAND, k) {
+ size_t offset_co;
+
+ index = BM_elem_index_get(v);
+
+ offset_co = index * size_vertex;
+ copy_v3_v3((float *)(vertex_data + offset_co), v->co);
+
+ if (k > 0) {
+ if (strands_use_normals(info)) {
+ size_t offset_nor = offset_co + size_v3;
+ float nor[3];
+ sub_v3_v3v3(nor, v->co, vprev->co);
+ normalize_v3(nor);
+ copy_v3_v3((float *)(vertex_data +
offset_nor), nor);
+
+ if (k == 1) {
+ /* define root normal: same as
first segment */
+ size_t offset_root_nor =
indexprev * size_vertex + size_v3;
+ copy_v3_v3((float
*)(vertex_data + offset_root_nor), nor);
+ }
+ }
+
+ {
+ elem_data[index_edge + 0] = indexprev;
+ elem_d
@@ Diff output truncated at 10240 characters. @@
_______________________________________________
Bf-blender-cvs mailing list
[email protected]
https://lists.blender.org/mailman/listinfo/bf-blender-cvs
