pidgin/pidgin
Clone
Summary
Browse
Changes
Graph
ChangeLog the external SASL fix
release-2.x.y
v2.12.0
2017-03-09, Gary Kramlich
0241f07ed2ba
ChangeLog the external SASL fix
#include
<assert.h>
#include
<string.h>
#include
<stdlib.h>
#include
<GL/gl.h>
#include
<GL/glu.h>
#include
<math.h>
/*#include "util.h"*/
#include
"cc_interface.h"
#include
"crazychat.h"
#include
<stdio.h>
#include
"cc_gtk_gl.h"
#include
"face.h"
#include
"glm.h"
#define TAN_30 0.577
#define ROOT_3 1.73
//this will be the width of all heads
#define HEAD_WIDTH 2.5
#define HEAD_HEIGHT 2.5
//same for now, this will actually vary from head
#define PERSONS_HEAD 1
#define MOVEMENT .33
GLfloat
ambient
[]
=
{
1.0
,
1.0
,
1.0
,
1.0
};
GLfloat
diffuse
[]
=
{
.7
,
.7
,
.7
,
1
};
GLfloat
specular
[]
=
{
1
,
1
,
1
,
1
};
GLfloat
lightpos
[]
=
{
0.0
,
0.0
,
20
,
1
};
GLfloat
specref
[]
=
{
1.0
,
1
,
1
,
1
,};
GLfloat
xrot
,
yrot
,
zrot
;
GLfloat
x
,
y
,
z
,
mouth_open
;
GLint
left_eye_frame
,
right_eye_frame
;
//between 0 - 8
GLint
mouth_type
;
GLint
mouth_frame
;
DIRECTION
dir
;
BOOL
left_open
,
right_open
;
GLfloat
window_aspect
;
FACE
remote_shark_face
,
remote_dog_face
,
local_shark_face
,
local_dog_face
;
int
count
=
0
;
int
curr_materials
[
DOG_SHARK_CHANGE
];
//these are the materials from output_instance
OUTPUT_MODE
curr_mode
;
KIND
which_face
;
static
void
destroy_cb
(
GtkWidget
*
widget
,
struct
output_instance
*
data
);
void
Interpolate
(
struct
output_instance
*
instance
){
GLfloat
rangeX
,
rangeY
,
minZ
,
adj
,
angle
,
temp
;
count
++
;
/* yrot=90;
zrot=0;
z=5;
x=0;
y=0;
left_open = right_open = TRUE;
mouth_open = (float)(count%10)/10;
dir = CONST;
curr_mode = NORMAL;
return;
*/
//find z plane from percentage of face
if
(
instance
->
features
->
head_size
==
0
){
z
=
5
;
}
temp
=
(
GLfloat
)
instance
->
features
->
head_size
/
40.0
;
//printf("head size %d\n", instance->features->head_size);
minZ
=
ROOT_3
;
z
=
ROOT_3
*
(
PERSONS_HEAD
/
temp
);
if
(
z
<
minZ
)
z
=
minZ
;
//these calculations are based on a 90 degree viewing angle
rangeX
=
z
*
(
TAN_30
)
*
2
;
rangeY
=
window_aspect
*
rangeX
;
temp
=
(
GLfloat
)
instance
->
features
->
x
;
if
(
temp
>
50
)
{
//then its on the left
temp
=
(
temp
-
50.0
)
/
50.0
;
x
=
0
-
temp
*
rangeX
/
1.0
;
}
else
{
temp
=
(
50.0
-
temp
)
/
50.0
;
x
=
0
+
temp
*
rangeX
/
1.0
;
}
temp
=
(
GLfloat
)
instance
->
features
->
y
;
if
(
temp
>
50
){
temp
=
(
temp
-50.0
)
/
50.0
;
y
=
0
-
temp
*
rangeY
/
1.0
;
}
else
{
temp
=
(
50.0
-
temp
)
/
50.0
;
y
=
0
+
temp
*
rangeY
/
1.0
;
}
temp
=
(
GLfloat
)
instance
->
features
->
head_y_rot
;
yrot
=
temp
-
50
;
temp
=
(
GLfloat
)
instance
->
features
->
head_z_rot
;
zrot
=
temp
-50
;
if
(
y
-
instance
->
past_y
<
-
MOVEMENT
)
dir
=
DOWN
;
else
if
(
y
-
instance
->
past_y
>
MOVEMENT
)
dir
=
UP
;
else
dir
=
CONST
;
instance
->
past_y
=
y
;
mouth_open
=
(
float
)
instance
->
features
->
mouth_open
/
105
;
count
++
;
//mouth_open = (count%10)/(10);
if
(
instance
->
features
->
left_eye_open
==
0
){
left_open
=
FALSE
;
}
else
{
left_open
=
TRUE
;
}
if
(
instance
->
features
->
right_eye_open
==
0
)
right_open
=
FALSE
;
else
right_open
=
TRUE
;
//right_open =1 - (count%5)/4;
//set the materials
curr_materials
[
APPENDAGE
]
=
instance
->
features
->
appendage_color
;
curr_materials
[
HEAD
]
=
instance
->
features
->
head_color
;
curr_materials
[
LIDS
]
=
instance
->
features
->
lid_color
;
curr_materials
[
LEFT_IRIS
]
=
instance
->
features
->
left_iris_color
;
curr_materials
[
RIGHT_IRIS
]
=
instance
->
features
->
right_iris_color
;
// we don't get an x rotation
xrot
=
0
;
curr_mode
=
instance
->
features
->
mode
;
if
(
instance
->
features
->
kind
==
0
)
which_face
=
DOG
;
else
which_face
=
SHARK
;
}
gboolean
configure
(
GtkWidget
*
widget
,
GdkEventConfigure
*
event
,
void
*
data
)
{
GdkGLContext
*
glcontext
=
gtk_widget_get_gl_context
(
widget
);
GdkGLDrawable
*
gldrawable
=
gtk_widget_get_gl_drawable
(
widget
);
GLfloat
w
=
widget
->
allocation
.
width
;
GLfloat
h
=
widget
->
allocation
.
height
;
GLfloat
aspect
;
Debug
(
"configuring
\n
"
);
/*** OpenGL BEGIN ***/
if
(
!
gdk_gl_drawable_gl_begin
(
gldrawable
,
glcontext
))
return
FALSE
;
glEnable
(
GL_DEPTH_TEST
);
glViewport
(
0
,
0
,
w
,
h
);
glMatrixMode
(
GL_PROJECTION
);
glLoadIdentity
();
if
(
w
>
h
)
{
window_aspect
=
w
/
h
;
}
else
{
window_aspect
=
h
/
w
;
}
//glOrtho(-10, 10, -10,10, 0.0001, 1000);
gluPerspective
(
90.0
,
window_aspect
,
0.0001
,
1000.0
);
glMatrixMode
(
GL_MODELVIEW
);
glLoadIdentity
();
gdk_gl_drawable_gl_end
(
gldrawable
);
/*** OpenGL END ***/
return
TRUE
;
}
gboolean
draw
(
GtkWidget
*
widget
,
GdkEventExpose
*
event
,
void
*
data
)
{
struct
output_instance
*
instance
=
(
struct
output_instance
*
)
data
;
if
(
!
data
)
{
fprintf
(
stderr
,
"null
\n
"
);
}
assert
(
instance
);
Interpolate
(
instance
);
GdkGLContext
*
glcontext
=
gtk_widget_get_gl_context
(
widget
);
GdkGLDrawable
*
gldrawable
=
gtk_widget_get_gl_drawable
(
widget
);
//return TRUE;
assert
(
gtk_widget_is_gl_capable
(
widget
));
if
(
!
gdk_gl_drawable_gl_begin
(
gldrawable
,
glcontext
))
{
fprintf
(
stderr
,
"We're fucked this time.
\n
"
);
return
FALSE
;
}
glClearColor
(
1.0
,
1.0
,
1.0
,
0.0
);
//glDisable(GL_CULL_FACE);
glClear
(
GL_COLOR_BUFFER_BIT
|
GL_DEPTH_BUFFER_BIT
);
glColor3f
(
1.0
,
1.0
,
1.0
);
glMatrixMode
(
GL_MODELVIEW
);
glLoadIdentity
();
glTranslatef
(
x
,
y
,
-
z
);
if
(
instance
->
my_output
==
LOCAL
){
if
(
which_face
==
DOG
){
change_materials
(
local_dog_face
,
curr_materials
,
DOG_SHARK_CHANGE
);
draw_face
(
local_dog_face
,
zrot
,
yrot
,
left_open
,
right_open
,
mouth_open
,
dir
,
curr_mode
);
}
else
{
change_materials
(
local_shark_face
,
curr_materials
,
DOG_SHARK_CHANGE
);
draw_face
(
local_shark_face
,
zrot
,
yrot
,
left_open
,
right_open
,
mouth_open
,
dir
,
curr_mode
);
}
}
else
{
if
(
which_face
==
DOG
){
change_materials
(
remote_dog_face
,
curr_materials
,
DOG_SHARK_CHANGE
);
draw_face
(
remote_dog_face
,
zrot
,
yrot
,
left_open
,
right_open
,
mouth_open
,
dir
,
curr_mode
);
}
else
{
change_materials
(
remote_shark_face
,
curr_materials
,
DOG_SHARK_CHANGE
);
draw_face
(
remote_shark_face
,
zrot
,
yrot
,
left_open
,
right_open
,
mouth_open
,
dir
,
curr_mode
);
}
}
if
(
gdk_gl_drawable_is_double_buffered
(
gldrawable
))
gdk_gl_drawable_swap_buffers
(
gldrawable
);
else
glFlush
();
return
TRUE
;
}
void
init
(
GtkWidget
*
widget
,
void
*
data
)
{
setupDrawlists
(
REMOTE
);
setupLighting
(
widget
);
}
void
setupDrawlists
(
OUTPUT
output
)
{
if
(
output
==
REMOTE
){
remote_shark_face
=
init_face
(
SHARK
);
remote_dog_face
=
init_face
(
DOG
);
}
if
(
output
==
LOCAL
){
local_shark_face
=
init_face
(
SHARK
);
local_dog_face
=
init_face
(
DOG
);
}
}
void
setupLighting
(
GtkWidget
*
widget
)
{
GLfloat
w
=
widget
->
allocation
.
width
;
GLfloat
h
=
widget
->
allocation
.
height
;
glClearColor
(
1.0f
,
1.0f
,
1.0f
,
1.0f
);
glEnable
(
GL_DEPTH_TEST
);
glEnable
(
GL_LIGHTING
);
//glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv
(
GL_LIGHT0
,
GL_DIFFUSE
,
diffuse
);
glLightfv
(
GL_LIGHT0
,
GL_SPECULAR
,
specular
);
glLightfv
(
GL_LIGHT0
,
GL_POSITION
,
lightpos
);
glEnable
(
GL_LIGHT0
);
//glEnable(GL_COLOR_MATERIAL);
//glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMaterialfv
(
GL_FRONT
,
GL_DIFFUSE
,
diffuse
);
glMateriali
(
GL_FRONT
,
GL_SHININESS
,
128
);
//glEnable(GL_CULL_FACE);
glClear
(
GL_COLOR_BUFFER_BIT
);
glMatrixMode
(
GL_PROJECTION
);
glLoadIdentity
();
//glOrtho(-2, 2, -2, 2, 0.0001, 1000);
if
(
w
>
h
)
{
window_aspect
=
w
/
h
;
}
else
{
window_aspect
=
h
/
w
;
}
gluPerspective
(
90.0
,
window_aspect
,
0.0001
,
1000.0
);
//glFrustum(-100.0, 100.0, -100.0, 100.0, 0, 10);
glMatrixMode
(
GL_MODELVIEW
);
//gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
struct
output_instance
*
init_output
(
struct
cc_features
*
features
,
struct
cc_session
*
session
)
{
struct
draw_info
*
info
;
struct
output_instance
*
instance
;
struct
window_box
ret
;
instance
=
(
struct
output_instance
*
)
malloc
(
sizeof
(
*
instance
));
assert
(
instance
);
memset
(
instance
,
0
,
sizeof
(
*
instance
));
instance
->
features
=
features
;
instance
->
session
=
session
;
info
=
(
struct
draw_info
*
)
malloc
(
sizeof
(
*
info
));
memset
(
info
,
0
,
sizeof
(
*
info
));
info
->
timeout
=
TRUE
;
info
->
delay_ms
=
40
;
info
->
data
=
instance
;
cc_new_gl_window
(
init
,
configure
,
draw
,
info
,
&
ret
);
g_signal_connect
(
GTK_OBJECT
(
ret
.
window
),
"destroy"
,
G_CALLBACK
(
destroy_cb
),
instance
);
gtk_window_set_default_size
(
ret
.
window
,
640
,
480
);
if
(
session
)
{
gtk_window_set_title
(
ret
.
window
,
session
->
name
);
}
gtk_widget_show
(
ret
.
window
);
instance
->
widget
=
ret
.
window
;
instance
->
box
=
ret
.
vbox
;
return
instance
;
}
static
void
destroy_cb
(
GtkWidget
*
widget
,
struct
output_instance
*
data
)
{
Debug
(
"Closing output window
\n
"
);
if
(
data
->
session
)
{
cc_remove_session
(
data
->
session
->
cc
,
data
->
session
);
close
(
data
->
session
->
tcp_sock
);
close
(
data
->
session
->
udp_sock
);
Filter_Destroy
(
data
->
session
->
filter
);
destroy_output
(
data
->
session
->
output
);
}
}
void
destroy_output
(
struct
output_instance
*
instance
)
{
free
(
instance
);
}