Page MenuHome
Differential D2548 Diff 8384 source/blender/editors/armature/editarmature_sketch.c

Changeset View

Standalone View

View Options

source/blender/editors/armature/editarmature_sketch.c

Context not available.
#include "ED_screen.h" #include "ED_screen.h"
#include "BIF_gl.h" #include "BIF_gl.h"
merwinUnsubmitted
Not Done
Inline Actions

Can remove this BIF_gl.h include.

merwin: Can remove this BIF_gl.h include.
#include "BIF_glutil.h"
#include "ED_armature.h" #include "ED_armature.h"
#include "armature_intern.h" #include "armature_intern.h"
#include "BIF_retarget.h" #include "BIF_retarget.h"
Context not available.
#include "WM_types.h" #include "WM_types.h"
#include "GPU_select.h" #include "GPU_select.h"
#include "GPU_matrix.h"
#include "GPU_batch.h"
#include "GPU_immediate.h"
typedef int (*GestureDetectFct)(bContext *, SK_Gesture *, SK_Sketch *); typedef int (*GestureDetectFct)(bContext *, SK_Gesture *, SK_Sketch *);
typedef void (*GestureApplyFct)(bContext *, SK_Gesture *, SK_Sketch *); typedef void (*GestureApplyFct)(bContext *, SK_Gesture *, SK_Sketch *);
Context not available.
} }
/**************************************************************/ /**************************************************************/
/**
* copy from imm_cylinder to avoid normal attribute
* because we can't use imm_cylinder with SHADER_3D_UNIFORM_COLOR now
*/
void sk_immCylinder(unsigned int pos, float base, float top, float height, int slices, int stacks)
fclemUnsubmitted
Not Done
Inline Actions

This belongs to glutil.c. Create imm_cylinder below imm_cylinder_nor.

fclem: This belongs to glutil.c. Create imm_cylinder below imm_cylinder_nor.
{
immBegin(GL_TRIANGLES, 6 * slices * stacks);
for (int i = 0; i < slices; ++i) {
const float angle1 = 2 * M_PI * ((float)i / (float)slices);
const float angle2 = 2 * M_PI * ((float)(i + 1) / (float)slices);
const float cos1 = cosf(angle1);
const float sin1 = sinf(angle1);
const float cos2 = cosf(angle2);
const float sin2 = sinf(angle2);
merwinUnsubmitted
Not Done
Inline Actions

Make this const float color[4] so we can pass in const colors. Not that it really matters but it's good practice.

merwin: Make this `const float color[4]` so we can pass in const colors. Not that it //really// matters…
for (int j = 0; j < stacks; ++j) {
float fac1 = (float)j / (float)stacks;
float fac2 = (float)(j + 1) / (float)stacks;
float r1 = base * (1.f - fac1) + top * fac1;
float r2 = base * (1.f - fac2) + top * fac2;
float h1 = height * ((float)j / (float)stacks);
float h2 = height * ((float)(j + 1) / (float)stacks);
float v1[3] = { r1 * cos2, r1 * sin2, h1 };
float v2[3] = { r2 * cos2, r2 * sin2, h2 };
merwinUnsubmitted
Not Done
Inline Actions

Small change, but makes it easier to read & understand:

Batch *batch = Batch_get_sphere(0);

And remove the "= NULL" above. Here & the other places.

merwin: Small change, but makes it easier to read & understand: ```lang=c Batch *batch =…
float v3[3] = { r2 * cos1, r2 * sin1, h2 };
float v4[3] = { r1 * cos1, r1 * sin1, h1 };
/* first tri */
immVertex3fv(pos, v1);
immVertex3fv(pos, v2);
immVertex3fv(pos, v3);
/* second tri */
merwinUnsubmitted
Not Done
Inline Actions

Same here, make it const color.

merwin: Same here, make it const color.
immVertex3fv(pos, v3);
immVertex3fv(pos, v4);
immVertex3fv(pos, v1);
}
}
immEnd();
}
static void sk_cancelStroke(SK_Sketch *sketch) static void sk_cancelStroke(SK_Sketch *sketch)
{ {
Context not available.
return max_ff(size * pt->size, size / 2); return max_ff(size * pt->size, size / 2);
} }
static void sk_drawPoint(GLUquadric *quad, SK_Point *pt, float size) static void sk_drawPoint(SK_Point *pt, float size, float color[4])
{ {
glTranslate3fv(pt->p); Batch *batch = NULL;
gluSphere(quad, sk_clampPointSize(pt, size), 8, 8);
gpuTranslate3fv(pt->p);
gpuPushMatrix();
gpuScaleUniform(sk_clampPointSize(pt, size));
batch = Batch_get_sphere(0);
Batch_set_builtin_program(batch, GPU_SHADER_3D_UNIFORM_COLOR);
Batch_Uniform4fv(batch, "color", color);
Batch_draw(batch);
gpuPopMatrix();
} }
static void sk_drawEdge(GLUquadric *quad, SK_Point *pt0, SK_Point *pt1, float size) static void sk_drawEdge(SK_Point *pt0, SK_Point *pt1, float size, float color[4])
{ {
float vec1[3], vec2[3] = {0, 0, 1}, axis[3]; float vec1[3], vec2[3] = { 0, 0, 1 }, axis[3];
float angle, length; float angle, length;
VertexFormat *format = immVertexFormat();
unsigned int pos = add_attrib(format, "pos", GL_FLOAT, 3, KEEP_FLOAT);
sub_v3_v3v3(vec1, pt1->p, pt0->p); sub_v3_v3v3(vec1, pt1->p, pt0->p);
length = normalize_v3(vec1); length = normalize_v3(vec1);
cross_v3_v3v3(axis, vec2, vec1); cross_v3_v3v3(axis, vec2, vec1);
Context not available.
axis[1] = 1; axis[1] = 1;
} }
angle = angle_normalized_v3v3(vec2, vec1); immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
immUniformColor4fv(color);
glRotate3fv(angle * (float)(180.0 / M_PI) + 180.0f, axis); angle = angle_normalized_v3v3(vec2, vec1);
gpuRotate3fv(angle * (float)(180.0 / M_PI) + 180.0f, axis);
sk_immCylinder(pos, sk_clampPointSize(pt1, size), sk_clampPointSize(pt0, size), length, 8, 8);
gluCylinder(quad, sk_clampPointSize(pt1, size), sk_clampPointSize(pt0, size), length, 8, 8); immUnbindProgram();
} }
static void sk_drawNormal(GLUquadric *quad, SK_Point *pt, float size, float height) static void sk_drawNormal(SK_Point *pt, float size, float height)
{ {
float vec2[3] = {0, 0, 1}, axis[3]; float vec2[3] = { 0, 0, 1 }, axis[3];
float angle; float angle;
float color[3] = { 0.0f, 1.0f, 1.0f };
glPushMatrix();
VertexFormat *format = immVertexFormat();
unsigned int pos = add_attrib(format, "pos", GL_FLOAT, 3, KEEP_FLOAT);
gpuPushMatrix();
cross_v3_v3v3(axis, vec2, pt->no); cross_v3_v3v3(axis, vec2, pt->no);
Context not available.
axis[1] = 1; axis[1] = 1;
} }
immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
immUniformColor4fv(color);
angle = angle_normalized_v3v3(vec2, pt->no); angle = angle_normalized_v3v3(vec2, pt->no);
gpuRotate3fv(angle * (float)(180.0 / M_PI), axis);
glRotate3fv(angle * (float)(180.0 / M_PI), axis); sk_immCylinder(pos, sk_clampPointSize(pt, size), 0, sk_clampPointSize(pt, height), 10, 2);
glColor3f(0, 1, 1); immUnbindProgram();
gluCylinder(quad, sk_clampPointSize(pt, size), 0, sk_clampPointSize(pt, height), 10, 2);
glPopMatrix(); gpuPopMatrix();
} }
static void sk_drawStroke(SK_Stroke *stk, int id, float color[3], int start, int end) static void sk_drawStroke(SK_Stroke *stk, int id, float color[3], int start, int end)
{ {
float rgb[3]; float rgb[3];
float zero_color[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
int i; int i;
GLUquadric *quad = gluNewQuadric();
gluQuadricNormals(quad, GLU_SMOOTH);
if (id != -1) { if (id != -1) {
GPU_select_load_id(id); GPU_select_load_id(id);
for (i = 0; i < stk->nb_points; i++) { for (i = 0; i < stk->nb_points; i++) {
glPushMatrix(); gpuPushMatrix();
sk_drawPoint(quad, stk->points + i, 0.1); sk_drawPoint(stk->points + i, 0.1, zero_color);
if (i > 0) { if (i > 0) {
sk_drawEdge(quad, stk->points + i - 1, stk->points + i, 0.1); sk_drawEdge(stk->points + i - 1, stk->points + i, 0.1, zero_color);
} }
glPopMatrix(); gpuPopMatrix();
} }
} }
else { else {
float d_rgb[3] = {1, 1, 1}; float d_rgb[3] = { 1, 1, 1 };
float tmp_color[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
copy_v3_v3(rgb, color); copy_v3_v3(rgb, color);
sub_v3_v3(d_rgb, rgb); sub_v3_v3(d_rgb, rgb);
Context not available.
for (i = 0; i < stk->nb_points; i++) { for (i = 0; i < stk->nb_points; i++) {
SK_Point *pt = stk->points + i; SK_Point *pt = stk->points + i;
glPushMatrix(); gpuPushMatrix();
if (pt->type == PT_EXACT) { if (pt->type == PT_EXACT) {
glColor3f(0, 0, 0); sk_drawPoint(pt, 0.15, zero_color);
sk_drawPoint(quad, pt, 0.15); sk_drawNormal(pt, 0.05, 0.9);
sk_drawNormal(quad, pt, 0.05, 0.9);
} }
if (i >= start && i <= end) { if (i >= start && i <= end) {
glColor3f(0.3, 0.3, 0.3); copy_v4_fl4(tmp_color, 0.3f, 0.3f, 0.3f, 1.0f);
} }
else { else {
glColor3fv(rgb); copy_v4_fl4(tmp_color, rgb[0], rgb[1], rgb[2], 1.0f);
} }
if (pt->type != PT_EXACT) { if (pt->type != PT_EXACT) {
sk_drawPoint(pt, 0.1, tmp_color);
sk_drawPoint(quad, pt, 0.1);
} }
if (i > 0) { if (i > 0) {
sk_drawEdge(quad, pt - 1, pt, 0.1); sk_drawEdge(pt - 1, pt, 0.1, tmp_color);
} }
glPopMatrix(); gpuPopMatrix();
add_v3_v3(rgb, d_rgb); add_v3_v3(rgb, d_rgb);
} }
} }
gluDeleteQuadric(quad);
} }
static void drawSubdividedStrokeBy(ToolSettings *toolsettings, BArcIterator *iter, NextSubdivisionFunc next_subdividion) static void drawSubdividedStrokeBy(ToolSettings *toolsettings, BArcIterator *iter, NextSubdivisionFunc next_subdividion)
{ {
SK_Stroke *stk = ((SK_StrokeIterator *)iter)->stroke; SK_Stroke *stk = ((SK_StrokeIterator *)iter)->stroke;
float head[3], tail[3]; float head[3], tail[3];
float color[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
int bone_start = 0; int bone_start = 0;
int end = iter->length; int end = iter->length;
int index; int index;
GLUquadric *quad = gluNewQuadric();
gluQuadricNormals(quad, GLU_SMOOTH);
iter->head(iter); iter->head(iter);
copy_v3_v3(head, iter->p); copy_v3_v3(head, iter->p);
Context not available.
while (index != -1) { while (index != -1) {
SK_Point *pt = stk->points + index; SK_Point *pt = stk->points + index;
glPushMatrix(); gpuPushMatrix();
glColor3f(0, 1, 0); sk_drawPoint(pt, 0.15, color);
sk_drawPoint(quad, pt, 0.15);
sk_drawNormal(quad, pt, 0.05, 0.9); sk_drawNormal(pt, 0.05, 0.9);
glPopMatrix(); gpuPopMatrix();
copy_v3_v3(head, tail); copy_v3_v3(head, tail);
bone_start = index; // start next bone from current index bone_start = index; // start next bone from current index
index = next_subdividion(toolsettings, iter, bone_start, end, head, tail); index = next_subdividion(toolsettings, iter, bone_start, end, head, tail);
} }
gluDeleteQuadric(quad);
} }
static void sk_drawStrokeSubdivision(ToolSettings *toolsettings, SK_Stroke *stk) static void sk_drawStrokeSubdivision(ToolSettings *toolsettings, SK_Stroke *stk)
Context not available.
glClear(GL_DEPTH_BUFFER_BIT); glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
gpuMatrixBegin3D_legacy();
if (with_names) { if (with_names) {
int id; int id;
for (id = 1, stk = sketch->strokes.first; stk; id++, stk = stk->next) { for (id = 1, stk = sketch->strokes.first; stk; id++, stk = stk->next) {
Context not available.
GPU_select_load_id(-1); GPU_select_load_id(-1);
} }
else { else {
float selected_rgb[3] = {1, 0, 0}; float selected_rgb[3] = { 1, 0, 0 };
float unselected_rgb[3] = {1, 0.5, 0}; float unselected_rgb[3] = { 1, 0.5, 0 };
float tmp_color[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
for (stk = sketch->strokes.first; stk; stk = stk->next) { for (stk = sketch->strokes.first; stk; stk = stk->next) {
int start = -1; int start = -1;
int end = -1; int end = -1;
Context not available.
} }
merwinUnsubmitted
Not Done
Inline Actions

I agree we should keep this disabled code even though it uses GLU. It is an example of what could be done here.

merwin: I agree we should keep this disabled code even though it uses GLU. It is an example of what…
if (last != NULL) { if (last != NULL) {
GLUquadric *quad = gluNewQuadric(); gpuPushMatrix();
gluQuadricNormals(quad, GLU_SMOOTH);
glPushMatrix();
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
switch (sketch->next_point.mode) { switch (sketch->next_point.mode) {
case PT_SNAP: case PT_SNAP:
glColor3f(0, 1, 0); copy_v4_fl4(tmp_color, 0.0f, 1.0f, 0.0f, 1.0f);
break; break;
case PT_PROJECT: case PT_PROJECT:
glColor3f(0, 0, 0); copy_v4_fl4(tmp_color, 0.0f, 0.0f, 0.0f, 1.0f);
break; break;
} }
sk_drawPoint(quad, &sketch->next_point, 0.1); sk_drawPoint(&sketch->next_point, 0.1, tmp_color);
glColor4f(selected_rgb[0], selected_rgb[1], selected_rgb[2], 0.3); copy_v4_fl4(tmp_color, selected_rgb[0], selected_rgb[1], selected_rgb[2], 0.3);
sk_drawEdge(last, &sketch->next_point, 0.1f, tmp_color);
sk_drawEdge(quad, last, &sketch->next_point, 0.1);
glDisable(GL_BLEND); glDisable(GL_BLEND);
glPopMatrix(); gpuPopMatrix();
gluDeleteQuadric(quad);
} }
} }
} }
Context not available.
#if 0 #if 0
if (BLI_listbase_is_empty(&sketch->depth_peels) == false) { if (BLI_listbase_is_empty(&sketch->depth_peels) == false) {
float colors[8][3] = { float colors[8][3] = {
{1, 0, 0}, { 1, 0, 0 },
{0, 1, 0}, { 0, 1, 0 },
{0, 0, 1}, { 0, 0, 1 },
{1, 1, 0}, { 1, 1, 0 },
{1, 0, 1}, { 1, 0, 1 },
{0, 1, 1}, { 0, 1, 1 },
{1, 1, 1}, { 1, 1, 1 },
{0, 0, 0} { 0, 0, 0 }
}; };
DepthPeel *p; DepthPeel *p;
GLUquadric *quad = gluNewQuadric(); GLUquadric *quad = gluNewQuadric();
Context not available.
/* only draw gesture in active area */ /* only draw gesture in active area */
if (sketch->gesture != NULL /* && area_is_active_area(G.vd->area) */) { if (sketch->gesture != NULL /* && area_is_active_area(G.vd->area) */) {
float gesture_rgb[3] = {0, 0.5, 1}; float gesture_rgb[3] = { 0, 0.5, 1 };
sk_drawStroke(sketch->gesture, -1, gesture_rgb, -1, -1); sk_drawStroke(sketch->gesture, -1, gesture_rgb, -1, -1);
} }
gpuMatrixEnd();
} }
static int sk_finish_stroke(bContext *C, SK_Sketch *sketch) static int sk_finish_stroke(bContext *C, SK_Sketch *sketch)
Context not available.