Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
ElmerCSC
GitHub Repository: ElmerCSC/elmerfem
 Path: blob/devel/post/src/glaux/xform.c
3203 views
1
/* xform.c */

2


3
#include <math.h>

4
#include <stdio.h>

5


6
#include <GL/gl.h>

7
#include <GL/glu.h>

8


9
#include "3d.h"

10


11


12


13
#define STACKDEPTH 10

14


15
typedef struct {

16
    GLdouble	mat[4][4];

17
    GLdouble	norm[3][3];

18
} mat_t;

19


20
static mat_t matstack[STACKDEPTH] = {

21
    {{{1.0, 0.0, 0.0, 0.0},

22
    {0.0, 1.0, 0.0, 0.0},

23
    {0.0, 0.0, 1.0, 0.0},

24
    {0.0, 0.0, 0.0, 1.0}},

25
    {{1.0, 0.0, 0.0},

26
    {0.0, 1.0, 0.0},

27
    {0.0, 0.0, 1.0}}}

28
};

29
static int identitymat = 1;

30


31
static int mattop = 0;

32


33
void m_xformpt(GLdouble pin[3], GLdouble pout[3], 

34
    GLdouble nin[3], GLdouble nout[3])

35
{

36
    int	i;

37
    GLdouble	ptemp[3], ntemp[3];

38
    mat_t	*m = &matstack[mattop];

39


40
    if (identitymat) {

41
	for (i = 0; i < 3; i++) {

42
	    pout[i] = pin[i];

43
	    nout[i] = nin[i];

44
	}

45
	return;

46
    }

47
    for (i = 0; i < 3; i++) {

48
	ptemp[i] = pin[0]*m->mat[0][i] +

49
		   pin[1]*m->mat[1][i] +

50
		   pin[2]*m->mat[2][i] +

51
		   m->mat[3][i];

52
	ntemp[i] = nin[0]*m->norm[0][i] +

53
		   nin[1]*m->norm[1][i] +

54
		   nin[2]*m->norm[2][i];

55
    }

56
    for (i = 0; i < 3; i++) {

57
	pout[i] = ptemp[i];

58
	nout[i] = ntemp[i];

59
    }

60
    normalize(nout);

61
}

62


63
void m_xformptonly(GLdouble pin[3], GLdouble pout[3])

64
{

65
    int	i;

66
    GLdouble	ptemp[3];

67
    mat_t	*m = &matstack[mattop];

68


69
    if (identitymat) {

70
	for (i = 0; i < 3; i++) {

71
	    pout[i] = pin[i];

72
	}

73
	return;

74
    }

75
     for (i = 0; i < 3; i++) {

76
	ptemp[i] = pin[0]*m->mat[0][i] +

77
		   pin[1]*m->mat[1][i] +

78
		   pin[2]*m->mat[2][i] +

79
		   m->mat[3][i];

80
    }

81
    for (i = 0; i < 3; i++) {

82
	pout[i] = ptemp[i];

83
    }

84
}

85


86
void m_pushmatrix(void)

87
{

88
  if (mattop < STACKDEPTH-1) {

89
    matstack[mattop+1] = matstack[mattop];

90
    mattop++;

91
  } else

92
    glaux_error("m_pushmatrix: stack overflow\n");

93
}

94


95
void m_popmatrix(void)

96
{

97
  if (mattop > 0)

98
    mattop--;

99
  else

100
    glaux_error("m_popmatrix: stack underflow\n");

101
}

102


103
void m_translate(GLdouble x, GLdouble y, GLdouble z)

104
{

105
    int	i;

106
    mat_t	*m = &matstack[mattop];

107


108
    identitymat = 0;

109
    for (i = 0; i < 4; i++)

110
	m->mat[3][i] = x*m->mat[0][i] +

111
				 y*m->mat[1][i] +

112
				 z*m->mat[2][i] +

113
				 m->mat[3][i];

114
}

115


116
void m_scale(GLdouble x, GLdouble y, GLdouble z)

117
{

118
    int	i;

119
    mat_t	*m = &matstack[mattop];

120


121
    identitymat = 0;

122
    for (i = 0; i < 3; i++) {

123
	m->mat[0][i] *= x;

124
	m->mat[1][i] *= y;

125
	m->mat[2][i] *= z;

126
    }

127
    for (i = 0; i < 3; i++) {

128
	m->norm[0][i] /= x;

129
	m->norm[1][i] /= y;

130
	m->norm[2][i] /= z;

131
    }

132
}

133


134