#
source:
src/materials/_normalisationCubemap.pym
@
1345:ff8ef9c6bbb7

Revision 1345:ff8ef9c6bbb7, 8.2 KB checked in by Arc Riley <arcriley@…>, 5 years ago (diff) |
---|

Line | |
---|---|

1 | # PySoy's materials._normalisationCubemap function |

2 | # |

3 | # Copyright (C) 2006,2007,2008,2009 PySoy Group |

4 | # |

5 | # This program is free software; you can redistribute it and/or modify |

6 | # it under the terms of the GNU Affero General Public License as published |

7 | # by the Free Software Foundation, either version 3 of the License, or |

8 | # (at your option) any later version. |

9 | # |

10 | # This program is distributed in the hope that it will be useful, |

11 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |

12 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |

13 | # GNU Affero General Public License for more details. |

14 | # |

15 | # You should have received a copy of the GNU Affero General Public License |

16 | # along with this program; if not, see http://www.gnu.org/licenses |

17 | # |

18 | # $Id: _normalisationCubemap.pym 1393 2008-12-31 23:51:25Z ArcRiley $ |

19 | |

20 | cimport stdlib |

21 | cimport soy.textures |

22 | |

23 | cdef void _normalisationCubemap(soy.textures.Texture _cubemap) : |

24 | cdef int _i, _j |

25 | cdef float _length |

26 | cdef float _vector[3] |

27 | cdef unsigned char* _ptr |

28 | # |

29 | ######################################## |

30 | # |

31 | # call the texture's _resize function |

32 | # |

33 | # This sets up many of the textures parameters and mallocs _texels |

34 | # In the future the first array (bytes) should be 4 for float, which should |

35 | # not only speed this up a bit but provide more accurate normalisation |

36 | # |

37 | _cubemap._resize(1, 3, 32, 32, 6) |

38 | # |

39 | ######################################## |

40 | # |

41 | # initialize _ptr to the texture's _texels |

42 | # |

43 | # we use _ptr to scan over the _texels data as it's generated, which is |

44 | # slightly faster than using _ptr as an int and adding it many times, ie: |

45 | # _ptr[0] = <unsigned char> (_vector[0] * 255) |

46 | # _ptr[1] = <unsigned char> (_vector[1] * 255) |

47 | # _ptr[2] = <unsigned char> (_vector[2] * 255) |

48 | # _ptr = _ptr + 3 |

49 | # |

50 | # vs the slower |

51 | # |

52 | # _cubemap._texels[_ptr ] = <unsigned char> (_vector[0] * 255) |

53 | # _cubemap._texels[_ptr+1] = <unsigned char> (_vector[0] * 255) |

54 | # _cubemap._texels[_ptr+2] = <unsigned char> (_vector[0] * 255) |

55 | # _ptr = _ptr + 3 |

56 | # |

57 | _ptr = _cubemap._texels |

58 | # |

59 | ############################################################################ |

60 | # |

61 | # This following code was derived from "Normalisation Cube Map.cpp" |

62 | # from http://paulsprojects.net/tutorials/simplebump/simplebump.html |

63 | # |

64 | # Copyright (c) 2006, Paul Baker |

65 | # All rights reserved. |

66 | # |

67 | # Redistribution and use in source and binary forms, with or without |

68 | # modification, are permitted provided that the following conditions are met: |

69 | # |

70 | # * Redistributions of source code must retain the above copyright notice, |

71 | # this list of conditions and the following disclaimer. |

72 | # * Redistributions in binary form must reproduce the above copyright |

73 | # notice, this list of conditions and the following disclaimer in the |

74 | # documentation and/or other materials provided with the distribution. |

75 | # * Neither the name of paulsprojects.net nor the names of its contributors |

76 | # may be used to endorse or promote products derived from this software |

77 | # without specific prior written permission. |

78 | # |

79 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |

80 | # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |

81 | # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |

82 | # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |

83 | # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |

84 | # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |

85 | # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |

86 | # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |

87 | # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |

88 | # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |

89 | # POSSIBILITY OF SUCH DAMAGE. |

90 | # |

91 | ######################################## |

92 | # |

93 | # +X |

94 | # |

95 | for _j from 0 < _j <= 32: |

96 | for _i from 0 < _i <= 32: |

97 | _vector[0] = 16.0 |

98 | _vector[1] = -(_j + 0.5 - 16.0) |

99 | _vector[2] = -(_i + 0.5 - 16.0) |

100 | |

101 | _length = stdlib.sqrtf( _vector[0] * _vector[0] + |

102 | _vector[1] * _vector[1] + |

103 | _vector[2] * _vector[2] ) |

104 | |

105 | _vector[0] = 0.5 * (_vector[0] / _length) + 0.5 |

106 | _vector[1] = 0.5 * (_vector[1] / _length) + 0.5 |

107 | _vector[2] = 0.5 * (_vector[2] / _length) + 0.5 |

108 | |

109 | _ptr[0] = <unsigned char> (_vector[0] * 255) |

110 | _ptr[1] = <unsigned char> (_vector[1] * 255) |

111 | _ptr[2] = <unsigned char> (_vector[2] * 255) |

112 | _ptr = _ptr + 3 |

113 | # |

114 | ######################################## |

115 | # |

116 | # -X |

117 | # |

118 | for _j from 0 < _j <= 32: |

119 | for _i from 0 < _i <= 32: |

120 | _vector[0] = -16.0 |

121 | _vector[1] = -(_j + 0.5 - 16.0) |

122 | _vector[2] = (_i + 0.5 - 16.0) |

123 | |

124 | _length = stdlib.sqrtf( _vector[0] * _vector[0] + |

125 | _vector[1] * _vector[1] + |

126 | _vector[2] * _vector[2] ) |

127 | |

128 | _vector[0] = 0.5 * (_vector[0] / _length) + 0.5 |

129 | _vector[1] = 0.5 * (_vector[1] / _length) + 0.5 |

130 | _vector[2] = 0.5 * (_vector[2] / _length) + 0.5 |

131 | |

132 | _ptr[0] = <unsigned char> (_vector[0] * 255) |

133 | _ptr[1] = <unsigned char> (_vector[1] * 255) |

134 | _ptr[2] = <unsigned char> (_vector[2] * 255) |

135 | _ptr = _ptr + 3 |

136 | # |

137 | ######################################## |

138 | # |

139 | # +Y |

140 | # |

141 | for _j from 0 < _j <= 32: |

142 | for _i from 0 < _i <= 32: |

143 | _vector[0] = (_i + 0.5 - 16.0) |

144 | _vector[1] = 16.0 |

145 | _vector[2] = (_j + 0.5 - 16.0) |

146 | |

147 | _length = stdlib.sqrtf( _vector[0] * _vector[0] + |

148 | _vector[1] * _vector[1] + |

149 | _vector[2] * _vector[2] ) |

150 | |

151 | _vector[0] = 0.5 * (_vector[0] / _length) + 0.5 |

152 | _vector[1] = 0.5 * (_vector[1] / _length) + 0.5 |

153 | _vector[2] = 0.5 * (_vector[2] / _length) + 0.5 |

154 | |

155 | _ptr[0] = <unsigned char> (_vector[0] * 255) |

156 | _ptr[1] = <unsigned char> (_vector[1] * 255) |

157 | _ptr[2] = <unsigned char> (_vector[2] * 255) |

158 | _ptr = _ptr + 3 |

159 | # |

160 | ######################################## |

161 | # |

162 | # -Y |

163 | # |

164 | for _j from 0 < _j <= 32: |

165 | for _i from 0 < _i <= 32: |

166 | _vector[0] = (_i + 0.5 - 16.0) |

167 | _vector[1] = -16.0 |

168 | _vector[2] = -(_j + 0.5 - 16.0) |

169 | |

170 | _length = stdlib.sqrtf( _vector[0] * _vector[0] + |

171 | _vector[1] * _vector[1] + |

172 | _vector[2] * _vector[2] ) |

173 | |

174 | _vector[0] = 0.5 * (_vector[0] / _length) + 0.5 |

175 | _vector[1] = 0.5 * (_vector[1] / _length) + 0.5 |

176 | _vector[2] = 0.5 * (_vector[2] / _length) + 0.5 |

177 | |

178 | _ptr[0] = <unsigned char> (_vector[0] * 255) |

179 | _ptr[1] = <unsigned char> (_vector[1] * 255) |

180 | _ptr[2] = <unsigned char> (_vector[2] * 255) |

181 | _ptr = _ptr + 3 |

182 | # |

183 | ######################################## |

184 | # |

185 | # +Z |

186 | # |

187 | for _j from 0 < _j <= 32: |

188 | for _i from 0 < _i <= 32: |

189 | _vector[0] = (_i + 0.5 - 16.0) |

190 | _vector[1] = -(_j + 0.5 - 16.0) |

191 | _vector[2] = 16.0 |

192 | |

193 | _length = stdlib.sqrtf( _vector[0] * _vector[0] + |

194 | _vector[1] * _vector[1] + |

195 | _vector[2] * _vector[2] ) |

196 | |

197 | _vector[0] = 0.5 * (_vector[0] / _length) + 0.5 |

198 | _vector[1] = 0.5 * (_vector[1] / _length) + 0.5 |

199 | _vector[2] = 0.5 * (_vector[2] / _length) + 0.5 |

200 | |

201 | _ptr[0] = <unsigned char> (_vector[0] * 255) |

202 | _ptr[1] = <unsigned char> (_vector[1] * 255) |

203 | _ptr[2] = <unsigned char> (_vector[2] * 255) |

204 | _ptr = _ptr + 3 |

205 | # |

206 | ######################################## |

207 | # |

208 | # -Z |

209 | # |

210 | for _j from 0 < _j <= 32: |

211 | for _i from 0 < _i <= 32: |

212 | _vector[0] = -(_i + 0.5 - 16.0) |

213 | _vector[1] = -(_j + 0.5 - 16.0) |

214 | _vector[2] = -16.0 |

215 | |

216 | _length = stdlib.sqrtf( _vector[0] * _vector[0] + |

217 | _vector[1] * _vector[1] + |

218 | _vector[2] * _vector[2] ) |

219 | |

220 | _vector[0] = 0.5 * (_vector[0] / _length) + 0.5 |

221 | _vector[1] = 0.5 * (_vector[1] / _length) + 0.5 |

222 | _vector[2] = 0.5 * (_vector[2] / _length) + 0.5 |

223 | |

224 | _ptr[0] = <unsigned char> (_vector[0] * 255) |

225 | _ptr[1] = <unsigned char> (_vector[1] * 255) |

226 | _ptr[2] = <unsigned char> (_vector[2] * 255) |

227 | _ptr = _ptr + 3 |

228 | # |

229 | ############################################################################ |

**Note:**See TracBrowser for help on using the repository browser.