OLD | NEW |
1 /* | 1 /* |
2 * ***** BEGIN GPL LICENSE BLOCK ***** | 2 * ***** BEGIN GPL LICENSE BLOCK ***** |
3 * | 3 * |
4 * This program is free software; you can redistribute it and/or | 4 * This program is free software; you can redistribute it and/or |
5 * modify it under the terms of the GNU General Public License | 5 * modify it under the terms of the GNU General Public License |
6 * as published by the Free Software Foundation; either version 2 | 6 * as published by the Free Software Foundation; either version 2 |
7 * of the License, or (at your option) any later version. | 7 * of the License, or (at your option) any later version. |
8 * | 8 * |
9 * This program is distributed in the hope that it will be useful, | 9 * This program is distributed in the hope that it will be useful, |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
(...skipping 4285 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4296 /* api callbacks */ | 4296 /* api callbacks */ |
4297 ot->exec = edbm_noise_exec; | 4297 ot->exec = edbm_noise_exec; |
4298 ot->poll = ED_operator_editmesh; | 4298 ot->poll = ED_operator_editmesh; |
4299 | 4299 |
4300 /* flags */ | 4300 /* flags */ |
4301 ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; | 4301 ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; |
4302 | 4302 |
4303 RNA_def_float(ot->srna, "factor", 0.1f, -FLT_MAX, FLT_MAX, "Factor", "",
0.0f, 1.0f); | 4303 RNA_def_float(ot->srna, "factor", 0.1f, -FLT_MAX, FLT_MAX, "Factor", "",
0.0f, 1.0f); |
4304 } | 4304 } |
4305 | 4305 |
4306 /* bevel! yay!!*/ | 4306 typedef struct { |
4307 static int edbm_bevel_exec(bContext *C, wmOperator *op) | 4307 » BMEditMesh *em; |
4308 { | 4308 » BMBackup mesh_backup; |
4309 » Object *obedit = CTX_data_edit_object(C); | 4309 » float *weights; |
4310 » BMEditMesh *em = BMEdit_FromObject(obedit); | |
4311 » BMIter iter; | |
4312 » BMEdge *eed; | |
4313 » BMOperator bmop; | |
4314 » float factor = RNA_float_get(op->ptr, "percent") /*, dfac */ /* UNUSED *
/, df, s; | |
4315 » int i, recursion = 1; /* RNA_int_get(op->ptr, "recursion"); */ /* temp r
emoved, see comment below */ | |
4316 » const int use_even = RNA_boolean_get(op->ptr, "use_even"); | |
4317 » const int use_dist = RNA_boolean_get(op->ptr, "use_dist"); | |
4318 » float *w = NULL, ftot; | |
4319 int li; | 4310 int li; |
4320 »······· | 4311 » int mcenter[2]; |
4321 » BM_data_layer_add(em->bm, &em->bm->edata, CD_PROP_FLT); | 4312 » float initial_length; |
4322 » li = CustomData_number_of_layers(&em->bm->edata, CD_PROP_FLT) - 1; | 4313 » int is_modal; |
4323 »······· | 4314 } BevelData; |
4324 » BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) { | 4315 |
4325 » » float d = len_v3v3(eed->v1->co, eed->v2->co); | 4316 #define HEADER_LENGTH 180 |
4326 » » float *dv = CustomData_bmesh_get_n(&em->bm->edata, eed->head.dat
a, CD_PROP_FLT, li); | 4317 |
4327 » »······· | 4318 static void edbm_bevel_update_header(wmOperator *op, bContext *C) |
4328 » » *dv = d; | 4319 { |
4329 » } | 4320 » static char str[] = "Confirm: Enter/LClick, Cancel: (Esc/RClick), factor
: %f, , Use Dist (D): %s: Use Even (E): %s"; |
4330 »······· | 4321 |
4331 » if (em == NULL) { | 4322 » char msg[HEADER_LENGTH]; |
4332 » » return OPERATOR_CANCELLED; | 4323 » ScrArea *sa = CTX_wm_area(C); |
4333 » } | 4324 |
4334 »······· | 4325 » if (sa) { |
4335 » w = MEM_mallocN(sizeof(float) * recursion, "bevel weights"); | 4326 » » BLI_snprintf(msg, HEADER_LENGTH, str, |
| 4327 » » » » » RNA_float_get(op->ptr, "percent"), |
| 4328 » » RNA_boolean_get(op->ptr, "use_dist") ? "On" : "Off"
, |
| 4329 » » RNA_boolean_get(op->ptr, "use_even") ? "On" : "Off" |
| 4330 » » » » » ); |
| 4331 |
| 4332 » » ED_area_headerprint(sa, msg); |
| 4333 » } |
| 4334 } |
| 4335 |
| 4336 static void edbm_bevel_recalc_weights(wmOperator *op) |
| 4337 { |
| 4338 » float df, s, ftot; |
| 4339 » int i; |
| 4340 » int recursion = 1; /* RNA_int_get(op->ptr, "recursion"); */ /* temp remo
ved, see comment below */ |
| 4341 » BevelData *opdata = op->customdata; |
| 4342 |
| 4343 » if(opdata->weights){ |
| 4344 » » /* TODO should change to free only when new recursion is greater
than old */ |
| 4345 » » MEM_freeN(opdata->weights); |
| 4346 » } |
| 4347 » opdata->weights = MEM_mallocN(sizeof(float) * recursion, "bevel weights"
); |
4336 | 4348 |
4337 /* ugh, stupid math depends somewhat on angles!*/ | 4349 /* ugh, stupid math depends somewhat on angles!*/ |
4338 /* dfac = 1.0/(float)(recursion + 1); */ /* UNUSED */ | 4350 /* dfac = 1.0/(float)(recursion + 1); */ /* UNUSED */ |
4339 df = 1.0; | 4351 df = 1.0; |
4340 for (i = 0, ftot = 0.0f; i < recursion; i++) { | 4352 for (i = 0, ftot = 0.0f; i < recursion; i++) { |
4341 s = powf(df, 1.25f); | 4353 s = powf(df, 1.25f); |
4342 | 4354 |
4343 » » w[i] = s; | 4355 » » opdata->weights[i] = s; |
4344 ftot += s; | 4356 ftot += s; |
4345 | 4357 |
4346 df *= 2.0f; | 4358 df *= 2.0f; |
4347 } | 4359 } |
4348 | 4360 |
4349 » mul_vn_fl(w, recursion, 1.0f / (float)ftot); | 4361 » mul_vn_fl(opdata->weights, recursion, 1.0f / (float)ftot); |
| 4362 } |
| 4363 |
| 4364 static int edbm_bevel_init(bContext *C, wmOperator *op, int is_modal) |
| 4365 { |
| 4366 » Object *obedit = CTX_data_edit_object(C); |
| 4367 » BMEditMesh *em = BMEdit_FromObject(obedit); |
| 4368 » BMIter iter; |
| 4369 » BMEdge *eed; |
| 4370 » BevelData *opdata; |
| 4371 » int li; |
| 4372 |
| 4373 » if (em == NULL) { |
| 4374 » » return 0; |
| 4375 » } |
| 4376 |
| 4377 » op->customdata = opdata = MEM_mallocN(sizeof(BevelData), "beveldata_mesh
_operator"); |
| 4378 |
| 4379 » BM_data_layer_add(em->bm, &em->bm->edata, CD_PROP_FLT); |
| 4380 » li = CustomData_number_of_layers(&em->bm->edata, CD_PROP_FLT) - 1; |
| 4381 |
| 4382 » BM_ITER_MESH (eed, &iter, em->bm, BM_EDGES_OF_MESH) { |
| 4383 » » float d = len_v3v3(eed->v1->co, eed->v2->co); |
| 4384 » » float *dv = CustomData_bmesh_get_n(&em->bm->edata, eed->head.dat
a, CD_PROP_FLT, li); |
| 4385 |
| 4386 » » *dv = d; |
| 4387 » } |
| 4388 |
| 4389 » opdata->em = em; |
| 4390 » opdata->li = li; |
| 4391 » opdata->weights = NULL; |
| 4392 » opdata->is_modal = is_modal; |
| 4393 |
| 4394 » /* avoid the cost of allocating a bm copy */ |
| 4395 » if(is_modal) |
| 4396 » » opdata->mesh_backup = EDBM_redo_state_store(em); |
| 4397 » edbm_bevel_recalc_weights(op); |
| 4398 |
| 4399 » return 1; |
| 4400 } |
| 4401 |
| 4402 static int edbm_bevel_calc(bContext *C, wmOperator *op) |
| 4403 { |
| 4404 » BevelData *opdata = op->customdata; |
| 4405 » BMEditMesh *em = opdata->em; |
| 4406 » BMOperator bmop; |
| 4407 » int i; |
| 4408 |
| 4409 » float factor = RNA_float_get(op->ptr, "percent") /*, dfac */ /* UNUSED *
/; |
| 4410 » int recursion = 1; /* RNA_int_get(op->ptr, "recursion"); */ /* temp remo
ved, see comment below */ |
| 4411 » const int use_even = RNA_boolean_get(op->ptr, "use_even"); |
| 4412 » const int use_dist = RNA_boolean_get(op->ptr, "use_dist"); |
| 4413 |
| 4414 » /* revert to original mesh */ |
| 4415 » if(opdata->is_modal) { |
| 4416 » » EDBM_redo_state_restore(opdata->mesh_backup, em, FALSE); |
| 4417 » } |
4350 | 4418 |
4351 for (i = 0; i < recursion; i++) { | 4419 for (i = 0; i < recursion; i++) { |
4352 » » float fac = w[recursion - i - 1] * factor; | 4420 » » float fac = opdata->weights[recursion - i - 1] * factor; |
| 4421 |
4353 | 4422 |
4354 if (!EDBM_op_init(em, &bmop, op, | 4423 if (!EDBM_op_init(em, &bmop, op, |
4355 "bevel geom=%hev percent=%f lengthlayer=%i use
_lengths=%b use_even=%b use_dist=%b", | 4424 "bevel geom=%hev percent=%f lengthlayer=%i use
_lengths=%b use_even=%b use_dist=%b", |
4356 » » BM_ELEM_SELECT, fac, li, TRUE, use_even, use_d
ist)) | 4425 » » BM_ELEM_SELECT, fac, opdata->li, TRUE, use_eve
n, use_dist)) |
4357 { | 4426 { |
4358 » » » return OPERATOR_CANCELLED; | 4427 » » » return 0; |
4359 } | 4428 } |
4360 » » | 4429 |
4361 BMO_op_exec(em->bm, &bmop); | 4430 BMO_op_exec(em->bm, &bmop); |
4362 if (!EDBM_op_finish(em, &bmop, op, TRUE)) | 4431 if (!EDBM_op_finish(em, &bmop, op, TRUE)) |
| 4432 return 0; |
| 4433 } |
| 4434 |
| 4435 EDBM_mesh_normals_update(opdata->em); |
| 4436 |
| 4437 EDBM_update_generic(C, opdata->em, TRUE); |
| 4438 |
| 4439 return 1; |
| 4440 } |
| 4441 |
| 4442 static void edbm_bevel_exit(bContext *C, wmOperator *op) |
| 4443 { |
| 4444 BevelData *opdata = op->customdata; |
| 4445 |
| 4446 ScrArea *sa = CTX_wm_area(C); |
| 4447 |
| 4448 if (sa) { |
| 4449 ED_area_headerprint(sa, NULL); |
| 4450 } |
| 4451 BM_data_layer_free_n(opdata->em->bm, &opdata->em->bm->edata, CD_PROP_FLT
, opdata->li); |
| 4452 |
| 4453 if(opdata->weights) |
| 4454 MEM_freeN(opdata->weights); |
| 4455 if(opdata->is_modal) { |
| 4456 EDBM_redo_state_free(&opdata->mesh_backup, NULL, FALSE); |
| 4457 } |
| 4458 MEM_freeN(opdata); |
| 4459 op->customdata = NULL; |
| 4460 } |
| 4461 |
| 4462 static int edbm_bevel_cancel(bContext *C, wmOperator *op) |
| 4463 { |
| 4464 BevelData *opdata = op->customdata; |
| 4465 if(opdata->is_modal) { |
| 4466 EDBM_redo_state_free(&opdata->mesh_backup, opdata->em, TRUE); |
| 4467 EDBM_update_generic(C, opdata->em, FALSE); |
| 4468 } |
| 4469 |
| 4470 edbm_bevel_exit(C, op); |
| 4471 |
| 4472 /* need to force redisplay or we may still view the modified result */ |
| 4473 ED_region_tag_redraw(CTX_wm_region(C)); |
| 4474 return OPERATOR_CANCELLED; |
| 4475 } |
| 4476 |
| 4477 /* bevel! yay!!*/ |
| 4478 static int edbm_bevel_exec(bContext *C, wmOperator *op) |
| 4479 { |
| 4480 if(!edbm_bevel_init(C, op, FALSE)) { |
| 4481 edbm_bevel_exit(C, op); |
| 4482 return OPERATOR_CANCELLED; |
| 4483 } |
| 4484 |
| 4485 if(!edbm_bevel_calc(C, op)) { |
| 4486 edbm_bevel_cancel(C, op); |
| 4487 return OPERATOR_CANCELLED; |
| 4488 } |
| 4489 |
| 4490 edbm_bevel_exit(C, op); |
| 4491 |
| 4492 return OPERATOR_FINISHED; |
| 4493 } |
| 4494 |
| 4495 static int edbm_bevel_invoke(bContext *C, wmOperator *op, wmEvent *event) |
| 4496 { |
| 4497 /* TODO make modal keymap (see fly mode) */ |
| 4498 BevelData *opdata; |
| 4499 float mlen[2]; |
| 4500 |
| 4501 if(!edbm_bevel_init(C, op, TRUE)) |
| 4502 return OPERATOR_CANCELLED; |
| 4503 |
| 4504 /* initialize mouse values */ |
| 4505 opdata = op->customdata; |
| 4506 |
| 4507 calculateTransformCenter(C, V3D_CENTROID, NULL, opdata->mcenter); |
| 4508 mlen[0] = opdata->mcenter[0] - event->mval[0]; |
| 4509 mlen[1] = opdata->mcenter[1] - event->mval[1]; |
| 4510 opdata->initial_length = len_v2(mlen); |
| 4511 |
| 4512 edbm_bevel_update_header(op, C); |
| 4513 |
| 4514 if(!edbm_bevel_calc(C, op)){ |
| 4515 edbm_bevel_cancel(C, op); |
| 4516 return OPERATOR_CANCELLED; |
| 4517 } |
| 4518 |
| 4519 WM_event_add_modal_handler(C, op); |
| 4520 |
| 4521 return OPERATOR_RUNNING_MODAL; |
| 4522 } |
| 4523 |
| 4524 static int edbm_bevel_modal(bContext *C, wmOperator *op, wmEvent *event) |
| 4525 { |
| 4526 BevelData *opdata = op->customdata; |
| 4527 // Scene *scene = CTX_data_scene(C); |
| 4528 |
| 4529 switch (event->type) { |
| 4530 case ESCKEY: |
| 4531 case RIGHTMOUSE: |
| 4532 edbm_bevel_cancel(C, op); |
4363 return OPERATOR_CANCELLED; | 4533 return OPERATOR_CANCELLED; |
4364 » } | 4534 |
4365 »······· | 4535 » » case MOUSEMOVE: |
4366 » BM_data_layer_free_n(em->bm, &em->bm->edata, CD_PROP_FLT, li); | 4536 » » { |
4367 »······· | 4537 » » » float factor; |
4368 » MEM_freeN(w); | 4538 » » » float mdiff[2]; |
4369 | 4539 |
4370 » EDBM_mesh_normals_update(em); | 4540 » » » mdiff[0] = opdata->mcenter[0] - event->mval[0]; |
4371 | 4541 » » » mdiff[1] = opdata->mcenter[1] - event->mval[1]; |
4372 » EDBM_update_generic(C, em, TRUE); | 4542 |
4373 | 4543 » » » factor = len_v2(mdiff)/opdata->initial_length; |
4374 » return OPERATOR_FINISHED; | 4544 » » » factor = MAX2(1.0 - factor, 0.0); |
| 4545 |
| 4546 » » » RNA_float_set(op->ptr, "percent", factor); |
| 4547 |
| 4548 » » » edbm_bevel_calc(C, op); |
| 4549 » » » edbm_bevel_update_header(op, C); |
| 4550 » » » return OPERATOR_RUNNING_MODAL; |
| 4551 » » } |
| 4552 |
| 4553 » » case LEFTMOUSE: |
| 4554 » » case PADENTER: |
| 4555 » » case RETKEY: |
| 4556 » » » edbm_bevel_calc(C, op); |
| 4557 » » » edbm_bevel_exit(C, op); |
| 4558 » » » return OPERATOR_FINISHED; |
| 4559 |
| 4560 » » case EKEY: |
| 4561 » » » if(event->val == KM_PRESS) { |
| 4562 » » » » int use_even = »RNA_boolean_get(op->ptr, "use_ev
en"); |
| 4563 » » » » RNA_boolean_set(op->ptr, "use_even", !use_even); |
| 4564 |
| 4565 » » » » edbm_bevel_calc(C, op); |
| 4566 » » » » edbm_bevel_update_header(op, C); |
| 4567 » » » } |
| 4568 » » » return OPERATOR_RUNNING_MODAL; |
| 4569 |
| 4570 » » case DKEY: |
| 4571 » » » if(event->val == KM_PRESS) { |
| 4572 » » » » int use_dist = »RNA_boolean_get(op->ptr, "use_di
st"); |
| 4573 » » » » RNA_boolean_set(op->ptr, "use_dist", !use_dist); |
| 4574 |
| 4575 » » » » edbm_bevel_calc(C, op); |
| 4576 » » » » edbm_bevel_update_header(op, C); |
| 4577 » » » } |
| 4578 » » » return OPERATOR_RUNNING_MODAL; |
| 4579 » } |
| 4580 |
| 4581 » return OPERATOR_RUNNING_MODAL; |
4375 } | 4582 } |
4376 | 4583 |
4377 void MESH_OT_bevel(wmOperatorType *ot) | 4584 void MESH_OT_bevel(wmOperatorType *ot) |
4378 { | 4585 { |
4379 /* identifiers */ | 4586 /* identifiers */ |
4380 ot->name = "Bevel"; | 4587 ot->name = "Bevel"; |
4381 ot->description = "Edge Bevel"; | 4588 ot->description = "Edge Bevel"; |
4382 ot->idname = "MESH_OT_bevel"; | 4589 ot->idname = "MESH_OT_bevel"; |
4383 | 4590 |
4384 /* api callbacks */ | 4591 /* api callbacks */ |
4385 ot->exec = edbm_bevel_exec; | 4592 ot->exec = edbm_bevel_exec; |
| 4593 ot->invoke = edbm_bevel_invoke; |
| 4594 ot->modal = edbm_bevel_modal; |
| 4595 ot->cancel = edbm_bevel_cancel; |
4386 ot->poll = ED_operator_editmesh; | 4596 ot->poll = ED_operator_editmesh; |
4387 | 4597 |
4388 /* flags */ | 4598 /* flags */ |
4389 ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; | 4599 ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; |
4390 | 4600 |
4391 » RNA_def_float(ot->srna, "percent", 0.5f, -FLT_MAX, FLT_MAX, "Percentage"
, "", 0.0f, 1.0f); | 4601 » RNA_def_float(ot->srna, "percent", 0.0f, -FLT_MAX, FLT_MAX, "Percentage"
, "", 0.0f, 1.0f); |
4392 // XXX, disabled for 2.63 release, needs to work much better without overlap be
fore we can give to users. | 4602 // XXX, disabled for 2.63 release, needs to work much better without overlap be
fore we can give to users. |
4393 // RNA_def_int(ot->srna, "recursion", 1, 1, 50, "Recursion Level", "Recursi
on Level", 1, 8); | 4603 // RNA_def_int(ot->srna, "recursion", 1, 1, 50, "Recursion Level", "Recursi
on Level", 1, 8); |
4394 | 4604 |
4395 RNA_def_boolean(ot->srna, "use_even", FALSE, "Even", "Calculate even
ly spaced bevel"); | 4605 RNA_def_boolean(ot->srna, "use_even", FALSE, "Even", "Calculate even
ly spaced bevel"); |
4396 RNA_def_boolean(ot->srna, "use_dist", FALSE, "Distance", "Interpret the
percent in blender units"); | 4606 RNA_def_boolean(ot->srna, "use_dist", FALSE, "Distance", "Interpret the
percent in blender units"); |
4397 | 4607 |
4398 } | 4608 } |
4399 | 4609 |
4400 static int edbm_bridge_edge_loops_exec(bContext *C, wmOperator *op) | 4610 static int edbm_bridge_edge_loops_exec(bContext *C, wmOperator *op) |
4401 { | 4611 { |
(...skipping 18 matching lines...) Expand all Loading... |
4420 /* api callbacks */ | 4630 /* api callbacks */ |
4421 ot->exec = edbm_bridge_edge_loops_exec; | 4631 ot->exec = edbm_bridge_edge_loops_exec; |
4422 ot->poll = ED_operator_editmesh; | 4632 ot->poll = ED_operator_editmesh; |
4423 ········ | 4633 ········ |
4424 /* flags */ | 4634 /* flags */ |
4425 ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; | 4635 ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; |
4426 ········ | 4636 ········ |
4427 RNA_def_boolean(ot->srna, "inside", 0, "Inside", ""); | 4637 RNA_def_boolean(ot->srna, "inside", 0, "Inside", ""); |
4428 } | 4638 } |
4429 | 4639 |
| 4640 typedef struct{ |
| 4641 float old_thickness; |
| 4642 float old_depth; |
| 4643 int mcenter[2]; |
| 4644 int modify_depth; |
| 4645 int is_modal; |
| 4646 float initial_length; |
| 4647 BMBackup backup; |
| 4648 BMEditMesh *em; |
| 4649 } InsetData; |
| 4650 |
| 4651 static void edbm_inset_update_header(wmOperator *op, bContext *C) |
| 4652 { |
| 4653 InsetData *opdata = op->customdata; |
| 4654 |
| 4655 static char str[] = "Confirm: Enter/LClick, Cancel: (Esc/RClick), thickn
ess: %f, depth (Ctrl to tweak): %f (%s), Outset (O): (%s)"; |
| 4656 |
| 4657 char msg[HEADER_LENGTH]; |
| 4658 ScrArea *sa = CTX_wm_area(C); |
| 4659 |
| 4660 if (sa) { |
| 4661 BLI_snprintf(msg, HEADER_LENGTH, str, |
| 4662 RNA_float_get(op->ptr, "thickness"), |
| 4663 RNA_float_get(op->ptr, "depth"), |
| 4664 opdata->modify_depth ? "On" : "Off", |
| 4665 RNA_boolean_get(op->ptr, "use_outset")
? "On" : "Off" |
| 4666 ); |
| 4667 |
| 4668 ED_area_headerprint(sa, msg); |
| 4669 } |
| 4670 } |
4430 | 4671 |
4431 | 4672 |
4432 static int edbm_inset_exec(bContext *C, wmOperator *op) | 4673 static int edbm_inset_init(bContext *C, wmOperator *op, int is_modal) |
4433 { | 4674 { |
| 4675 InsetData *opdata; |
4434 Object *obedit = CTX_data_edit_object(C); | 4676 Object *obedit = CTX_data_edit_object(C); |
4435 BMEditMesh *em = BMEdit_FromObject(obedit); | 4677 BMEditMesh *em = BMEdit_FromObject(obedit); |
| 4678 |
| 4679 op->customdata = opdata = MEM_mallocN(sizeof(InsetData), "inset_operator
_data"); |
| 4680 |
| 4681 opdata->old_thickness = 0.01; |
| 4682 opdata->old_depth = 0.0; |
| 4683 opdata->modify_depth = FALSE; |
| 4684 opdata->is_modal = is_modal; |
| 4685 opdata->em = em; |
| 4686 |
| 4687 if(is_modal) |
| 4688 opdata->backup = EDBM_redo_state_store(em); |
| 4689 |
| 4690 return 1; |
| 4691 } |
| 4692 |
| 4693 static void edbm_inset_exit(bContext *C, wmOperator *op) |
| 4694 { |
| 4695 InsetData *opdata; |
| 4696 ScrArea *sa = CTX_wm_area(C); |
| 4697 |
| 4698 opdata = op->customdata; |
| 4699 |
| 4700 if(opdata->is_modal) |
| 4701 EDBM_redo_state_free(&opdata->backup, NULL, FALSE); |
| 4702 |
| 4703 if (sa) { |
| 4704 ED_area_headerprint(sa, NULL); |
| 4705 } |
| 4706 MEM_freeN(op->customdata); |
| 4707 } |
| 4708 |
| 4709 static int edbm_inset_cancel(bContext *C, wmOperator *op) |
| 4710 { |
| 4711 InsetData *opdata; |
| 4712 |
| 4713 opdata = op->customdata; |
| 4714 if(opdata->is_modal) { |
| 4715 EDBM_redo_state_free(&opdata->backup, opdata->em, TRUE); |
| 4716 EDBM_update_generic(C, opdata->em, FALSE); |
| 4717 } |
| 4718 |
| 4719 edbm_inset_exit(C, op); |
| 4720 |
| 4721 /* need to force redisplay or we may still view the modified result */ |
| 4722 ED_region_tag_redraw(CTX_wm_region(C)); |
| 4723 return OPERATOR_CANCELLED; |
| 4724 } |
| 4725 |
| 4726 static int edbm_inset_calc(bContext *C, wmOperator *op) |
| 4727 { |
| 4728 InsetData *opdata; |
| 4729 BMEditMesh *em; |
4436 BMOperator bmop; | 4730 BMOperator bmop; |
4437 » const int use_boundary = RNA_boolean_get(op->ptr, "use_boundary")
; | 4731 |
4438 » const int use_even_offset = RNA_boolean_get(op->ptr, "use_even_offse
t"); | 4732 » int use_boundary = RNA_boolean_get(op->ptr, "use_boundary"); |
4439 » const int use_relative_offset = RNA_boolean_get(op->ptr, "use_relative_o
ffset"); | 4733 » int use_even_offset = RNA_boolean_get(op->ptr, "use_even_offset"); |
4440 » const float thickness = RNA_float_get(op->ptr, "thickness"); | 4734 » int use_relative_offset = RNA_boolean_get(op->ptr, "use_relative_offset"
); |
4441 » const float depth = RNA_float_get(op->ptr, "depth"); | 4735 » float thickness = RNA_float_get(op->ptr, "thickness"); |
4442 » const int use_outset = RNA_boolean_get(op->ptr, "use_outset"); | 4736 » float depth = RNA_float_get(op->ptr, "depth"); |
4443 » const int use_select_inset = RNA_boolean_get(op->ptr, "use_select_ins
et"); /* not passed onto the BMO */ | 4737 » int use_outset = RNA_boolean_get(op->ptr, "use_outset"); |
| 4738 » int use_select_inset = RNA_boolean_get(op->ptr, "use_select_inset");
/* not passed onto the BMO */ |
| 4739 |
| 4740 » opdata = op->customdata; |
| 4741 » em = opdata->em; |
| 4742 |
| 4743 » if(opdata->is_modal) { |
| 4744 » » EDBM_redo_state_restore(opdata->backup, em, FALSE); |
| 4745 » } |
4444 | 4746 |
4445 EDBM_op_init(em, &bmop, op, | 4747 EDBM_op_init(em, &bmop, op, |
4446 "inset faces=%hf use_boundary=%b use_even_offset=%b use_rel
ative_offset=%b " | 4748 "inset faces=%hf use_boundary=%b use_even_offset=%b use_rel
ative_offset=%b " |
4447 "thickness=%f depth=%f use_outset=%b", | 4749 "thickness=%f depth=%f use_outset=%b", |
4448 BM_ELEM_SELECT, use_boundary, use_even_offset, use_relative
_offset, | 4750 BM_ELEM_SELECT, use_boundary, use_even_offset, use_relative
_offset, |
4449 thickness, depth, use_outset); | 4751 thickness, depth, use_outset); |
4450 | 4752 |
4451 BMO_op_exec(em->bm, &bmop); | 4753 BMO_op_exec(em->bm, &bmop); |
4452 | 4754 |
4453 if (use_select_inset) { | 4755 if (use_select_inset) { |
4454 /* deselect original faces/verts */ | 4756 /* deselect original faces/verts */ |
4455 EDBM_flag_disable_all(em, BM_ELEM_SELECT); | 4757 EDBM_flag_disable_all(em, BM_ELEM_SELECT); |
4456 BMO_slot_buffer_hflag_enable(em->bm, &bmop, "faceout", BM_FACE,
BM_ELEM_SELECT, TRUE); | 4758 BMO_slot_buffer_hflag_enable(em->bm, &bmop, "faceout", BM_FACE,
BM_ELEM_SELECT, TRUE); |
4457 } | 4759 } |
4458 else { | 4760 else { |
4459 BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE, BM_ELE
M_SELECT, FALSE); | 4761 BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE, BM_ELE
M_SELECT, FALSE); |
4460 BMO_slot_buffer_hflag_disable(em->bm, &bmop, "faceout", BM_FACE,
BM_ELEM_SELECT, FALSE); | 4762 BMO_slot_buffer_hflag_disable(em->bm, &bmop, "faceout", BM_FACE,
BM_ELEM_SELECT, FALSE); |
4461 /* re-select faces so the verts and edges get selected too */ | 4763 /* re-select faces so the verts and edges get selected too */ |
4462 BM_mesh_elem_hflag_enable_test(em->bm, BM_FACE, BM_ELEM_SELECT,
TRUE, BM_ELEM_SELECT); | 4764 BM_mesh_elem_hflag_enable_test(em->bm, BM_FACE, BM_ELEM_SELECT,
TRUE, BM_ELEM_SELECT); |
4463 } | 4765 } |
4464 | 4766 |
4465 if (!EDBM_op_finish(em, &bmop, op, TRUE)) { | 4767 if (!EDBM_op_finish(em, &bmop, op, TRUE)) { |
4466 » » return OPERATOR_CANCELLED; | 4768 » » return 0; |
4467 } | 4769 } |
4468 else { | 4770 else { |
4469 EDBM_update_generic(C, em, TRUE); | 4771 EDBM_update_generic(C, em, TRUE); |
4470 » » return OPERATOR_FINISHED; | 4772 » » return 1; |
4471 } | 4773 } |
4472 } | 4774 } |
4473 | 4775 |
| 4776 static int edbm_inset_exec(bContext *C, wmOperator *op) |
| 4777 { |
| 4778 edbm_inset_init(C, op, FALSE); |
| 4779 |
| 4780 if(!edbm_inset_calc(C, op)) { |
| 4781 edbm_inset_exit(C, op); |
| 4782 return OPERATOR_CANCELLED; |
| 4783 } |
| 4784 |
| 4785 edbm_inset_exit(C, op); |
| 4786 return OPERATOR_FINISHED; |
| 4787 } |
| 4788 |
| 4789 static int edbm_inset_invoke(bContext *C, wmOperator *op, wmEvent *event) |
| 4790 { |
| 4791 InsetData *opdata; |
| 4792 float mlen[2]; |
| 4793 |
| 4794 edbm_inset_init(C, op, TRUE); |
| 4795 |
| 4796 opdata = op->customdata; |
| 4797 |
| 4798 calculateTransformCenter(C, V3D_CENTROID, NULL, opdata->mcenter); |
| 4799 /* initialize mouse values */ |
| 4800 mlen[0] = opdata->mcenter[0] - event->mval[0]; |
| 4801 mlen[1] = opdata->mcenter[1] - event->mval[1]; |
| 4802 opdata->initial_length = len_v2(mlen); |
| 4803 |
| 4804 edbm_inset_calc(C, op); |
| 4805 |
| 4806 edbm_inset_update_header(op, C); |
| 4807 |
| 4808 WM_event_add_modal_handler(C, op); |
| 4809 return OPERATOR_RUNNING_MODAL; |
| 4810 } |
| 4811 |
| 4812 static int edbm_inset_modal(bContext *C, wmOperator *op, wmEvent *event) |
| 4813 { |
| 4814 InsetData *opdata; |
| 4815 |
| 4816 opdata = op->customdata; |
| 4817 |
| 4818 switch (event->type) { |
| 4819 case ESCKEY: |
| 4820 case RIGHTMOUSE: |
| 4821 edbm_inset_cancel(C, op); |
| 4822 return OPERATOR_CANCELLED; |
| 4823 |
| 4824 case MOUSEMOVE: |
| 4825 { |
| 4826 float mdiff[2]; |
| 4827 float amount; |
| 4828 |
| 4829 mdiff[0] = opdata->mcenter[0] - event->mval[0]; |
| 4830 mdiff[1] = opdata->mcenter[1] - event->mval[1]; |
| 4831 |
| 4832 if(opdata->modify_depth) { |
| 4833 amount = opdata->old_depth + (len_v2(mdiff) |
| 4834 - opdata->initial_length)/opdata->initial_length
; |
| 4835 RNA_float_set(op->ptr, "depth", amount); |
| 4836 } else { |
| 4837 amount = opdata->old_thickness - (len_v2(mdiff) |
| 4838 - opdata->initial_length)/opdata->initial_le
ngth; |
| 4839 amount = MAX2(amount, 0.0); |
| 4840 |
| 4841 RNA_float_set(op->ptr, "thickness", amount); |
| 4842 } |
| 4843 |
| 4844 if(edbm_inset_calc(C, op)){ |
| 4845 edbm_inset_update_header(op, C); |
| 4846 return OPERATOR_RUNNING_MODAL; |
| 4847 } else { |
| 4848 edbm_inset_cancel(C, op); |
| 4849 return OPERATOR_CANCELLED; |
| 4850 } |
| 4851 } |
| 4852 |
| 4853 case LEFTMOUSE: |
| 4854 case PADENTER: |
| 4855 case RETKEY: |
| 4856 edbm_inset_calc(C, op); |
| 4857 edbm_inset_exit(C, op); |
| 4858 return OPERATOR_FINISHED; |
| 4859 |
| 4860 |
| 4861 case LEFTCTRLKEY: |
| 4862 case RIGHTCTRLKEY: |
| 4863 { |
| 4864 float mlen[2]; |
| 4865 |
| 4866 mlen[0] = opdata->mcenter[0] - event->mval[0]; |
| 4867 mlen[1] = opdata->mcenter[1] - event->mval[1]; |
| 4868 |
| 4869 if(event->val == KM_PRESS) {···················· |
| 4870 opdata->old_thickness = RNA_float_get(op->ptr, "
thickness"); |
| 4871 opdata->modify_depth = TRUE; |
| 4872 } else { |
| 4873 opdata->old_depth = RNA_float_get(op->ptr, "dept
h"); |
| 4874 opdata->modify_depth = FALSE; |
| 4875 } |
| 4876 opdata->initial_length = len_v2(mlen); |
| 4877 |
| 4878 edbm_inset_update_header(op, C); |
| 4879 return OPERATOR_RUNNING_MODAL; |
| 4880 } |
| 4881 |
| 4882 case OKEY: |
| 4883 if(event->val == KM_PRESS) { |
| 4884 int use_outset = RNA_boolean_get(op->ptr, "use_o
utset"); |
| 4885 RNA_boolean_set(op->ptr, "use_outset", !use_outs
et); |
| 4886 if(edbm_inset_calc(C, op)){ |
| 4887 edbm_inset_update_header(op, C); |
| 4888 return OPERATOR_RUNNING_MODAL; |
| 4889 } else { |
| 4890 edbm_inset_cancel(C, op); |
| 4891 return OPERATOR_CANCELLED; |
| 4892 } |
| 4893 } |
| 4894 } |
| 4895 |
| 4896 return OPERATOR_RUNNING_MODAL; |
| 4897 } |
| 4898 |
| 4899 |
4474 void MESH_OT_inset(wmOperatorType *ot) | 4900 void MESH_OT_inset(wmOperatorType *ot) |
4475 { | 4901 { |
4476 PropertyRNA *prop; | 4902 PropertyRNA *prop; |
4477 | 4903 |
4478 /* identifiers */ | 4904 /* identifiers */ |
4479 ot->name = "Inset Faces"; | 4905 ot->name = "Inset Faces"; |
4480 ot->idname = "MESH_OT_inset"; | 4906 ot->idname = "MESH_OT_inset"; |
4481 ot->description = "Inset new faces into selected faces"; | 4907 ot->description = "Inset new faces into selected faces"; |
4482 | 4908 |
4483 /* api callbacks */ | 4909 /* api callbacks */ |
| 4910 ot->invoke = edbm_inset_invoke; |
| 4911 ot->modal = edbm_inset_modal; |
4484 ot->exec = edbm_inset_exec; | 4912 ot->exec = edbm_inset_exec; |
| 4913 ot->cancel = edbm_inset_cancel; |
4485 ot->poll = ED_operator_editmesh; | 4914 ot->poll = ED_operator_editmesh; |
4486 | 4915 |
4487 /* flags */ | 4916 /* flags */ |
4488 ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; | 4917 ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; |
4489 | 4918 |
4490 /* properties */ | 4919 /* properties */ |
4491 RNA_def_boolean(ot->srna, "use_boundary", TRUE, "Boundary", "Ins
et face boundaries"); | 4920 RNA_def_boolean(ot->srna, "use_boundary", TRUE, "Boundary", "Ins
et face boundaries"); |
4492 RNA_def_boolean(ot->srna, "use_even_offset", TRUE, "Offset Even",
"Scale the offset to give more even thickness"); | 4921 RNA_def_boolean(ot->srna, "use_even_offset", TRUE, "Offset Even",
"Scale the offset to give more even thickness"); |
4493 » RNA_def_boolean(ot->srna, "use_relative_offset", FALSE, "Offset Relative
", "Scale the offset by surrounding geometry"); | 4922 » RNA_def_boolean(ot->srna, "use_relative_offset", TRUE, "Offset Relative"
, "Scale the offset by surrounding geometry"); |
4494 | 4923 |
4495 prop = RNA_def_float(ot->srna, "thickness", 0.01f, 0.0f, FLT_MAX, "Thick
ness", "", 0.0f, 10.0f); | 4924 prop = RNA_def_float(ot->srna, "thickness", 0.01f, 0.0f, FLT_MAX, "Thick
ness", "", 0.0f, 10.0f); |
4496 /* use 1 rather then 10 for max else dragging the button moves too far *
/ | 4925 /* use 1 rather then 10 for max else dragging the button moves too far *
/ |
4497 RNA_def_property_ui_range(prop, 0.0, 1.0, 0.01, 4); | 4926 RNA_def_property_ui_range(prop, 0.0, 1.0, 0.01, 4); |
4498 prop = RNA_def_float(ot->srna, "depth", 0.0f, -FLT_MAX, FLT_MAX, "Depth"
, "", -10.0f, 10.0f); | 4927 prop = RNA_def_float(ot->srna, "depth", 0.0f, -FLT_MAX, FLT_MAX, "Depth"
, "", -10.0f, 10.0f); |
4499 RNA_def_property_ui_range(prop, -10.0f, 10.0f, 0.01, 4); | 4928 RNA_def_property_ui_range(prop, -10.0f, 10.0f, 0.01, 4); |
4500 | 4929 |
4501 RNA_def_boolean(ot->srna, "use_outset", FALSE, "Outset", "Outset rather
than inset"); | 4930 RNA_def_boolean(ot->srna, "use_outset", FALSE, "Outset", "Outset rather
than inset"); |
4502 RNA_def_boolean(ot->srna, "use_select_inset", TRUE, "Select Outer", "Sel
ect the new inset faces"); | 4931 RNA_def_boolean(ot->srna, "use_select_inset", TRUE, "Select Outer", "Sel
ect the new inset faces"); |
4503 } | 4932 } |
(...skipping 153 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4657 RNA_def_boolean(ot->srna, "make_holes", FALSE, | 5086 RNA_def_boolean(ot->srna, "make_holes", FALSE, |
4658 "Make Holes", | 5087 "Make Holes", |
4659 "Delete selected faces that are used by
the hull"); | 5088 "Delete selected faces that are used by
the hull"); |
4660 | 5089 |
4661 RNA_def_boolean(ot->srna, "join_triangles", TRUE, | 5090 RNA_def_boolean(ot->srna, "join_triangles", TRUE, |
4662 "Join Triangles", | 5091 "Join Triangles", |
4663 "Merge adjacent triangles into quads"); | 5092 "Merge adjacent triangles into quads"); |
4664 | 5093 |
4665 join_triangle_props(ot); | 5094 join_triangle_props(ot); |
4666 } | 5095 } |
OLD | NEW |