source: trunk/src/gfx/mesh_creator.cc @ 294

Last change on this file since 294 was 294, checked in by epyon, 11 years ago
  • mesh_creator -- very robust tangent generation mechanism
  • keyframed_mesh - support for meshes with tangent data
  • minor cleanups
File size: 10.6 KB
RevLine 
[293]1// Copyright (C) 2012-2014 ChaosForge Ltd
2// http://chaosforge.org/
3//
4// This file is part of NV Libraries.
5// For conditions of distribution and use, see copyright notice in nv.hh
6
7#include "nv/gfx/mesh_creator.hh"
8
9struct nv_key_transform { nv::transform tform; };
10
11void nv::mesh_nodes_creator::pre_transform_keys()
12{
13        if ( m_data->m_flat ) return;
14        merge_keys();
15        uint32 max_frames = 0;
16        for ( size_t i = 0; i < m_data->get_count(); ++i )
17        {
18                sint16 parent_id = m_data->m_nodes[i].parent_id;
19                key_data* keys   = m_data->m_nodes[i].data;
20                key_data* pkeys  = ( parent_id != -1 ? m_data->m_nodes[parent_id].data : nullptr );
21                size_t count     = ( keys ? keys->get_channel(0)->count : 0 );
22                size_t pcount    = ( pkeys ? pkeys->get_channel(0)->count : 0 );
23                max_frames = glm::max<uint32>( count, max_frames );
24                if ( pkeys && pkeys->get_channel_count() > 0 && keys && keys->get_channel_count() > 0 )
25                {
26                        nv_key_transform*  channel = ((nv_key_transform*)(keys->get_channel(0)->data));
27                        nv_key_transform* pchannel = ((nv_key_transform*)(pkeys->get_channel(0)->data));
28                        for ( unsigned n = 0; n < count; ++n )
29                        {
30                                channel[n].tform = pchannel[ glm::min( n, pcount-1 ) ].tform * channel[n].tform;
31                        }
32                }
33        }
34
35        // DAE pre_transform hack
36        if ( m_data->m_frame_rate == 1 )
37        {
38                m_data->m_frame_rate = 32;
39                m_data->m_duration   = (float)max_frames;
40        }
41
42        m_data->m_flat = true;
43}
44
45// TODO: DELETE
46struct assimp_key_p  { float time; nv::vec3 position; };
47struct assimp_key_r  { float time; nv::quat rotation; };
48
49
50void nv::mesh_nodes_creator::merge_keys()
51{
52        for ( size_t i = 0; i < m_data->get_count(); ++i )
53        {
54                key_data* old_keys = m_data->m_nodes[i].data;
55                if ( old_keys && old_keys->get_channel_count() > 0 )
56                {
57                        size_t chan_count = old_keys->get_channel_count();
58                        if ( chan_count == 1
59                                && old_keys->get_channel(0)->desc.count == 1
60                                && old_keys->get_channel(0)->desc.slots[0].etype == TRANSFORM ) continue;
61
62                        size_t max_keys = 0;
63                        for ( size_t c = 0; c < chan_count; ++c )
64                        {
65                                max_keys = glm::max( max_keys, old_keys->get_channel(c)->count );
66                        }
67
68                        key_raw_channel* raw_channel = key_raw_channel::create<nv_key_transform>( max_keys );
69                        key_data* new_keys = new key_data;
70                        new_keys->add_channel( raw_channel );
71                        nv_key_transform* channel = ((nv_key_transform*)(raw_channel->data));
72                        key_descriptor final_key = old_keys->get_final_key();
73
74                        for ( unsigned n = 0; n < max_keys; ++n )
75                        {
76                                float key[ 16 ];
77                                float* pkey = key;
78
79                                for ( uint16 c = 0; c < chan_count; ++c )
80                                {
81                                        size_t idx = glm::min( old_keys->get_channel(c)->count - 1, n );
82                                        pkey += old_keys->get_channel(c)->get_raw( idx, pkey );
83                                }
84                                channel[n].tform = extract_transform_raw( final_key, key );
85                        }
86
87                        delete old_keys;
88                        m_data->m_nodes[i].data = new_keys;
89                }
90        }
91}
92
93void nv::mesh_nodes_creator::transform( float scale, const mat3& r33 )
94{
95        mat3 ri33 = glm::inverse( r33 );
96        mat4 pre_transform ( scale * r33 );
97        mat4 post_transform( 1.f/scale * ri33 );
98
99        for ( size_t i = 0; i < m_data->get_count(); ++i )
100        {
101                mesh_node_data& node = m_data->m_nodes[i];
102                node.transform = pre_transform * node.transform * post_transform;
103                if ( node.data )
104                {
105                        key_data* kdata  = node.data;
106                        for ( size_t c = 0; c < kdata->get_channel_count(); ++c )
107                        {
108                                const key_raw_channel* channel = kdata->get_channel(c);
109                                size_t key_size = channel->desc.size;
110                                for ( size_t n = 0; n < channel->count; ++n )
111                                {
112                                        transform_key_raw( channel->desc, (uint8*)(channel->data + n * key_size), scale, r33, ri33 );
113                                }
114                        }
115                }
116        }
117}
118
119void nv::mesh_data_creator::transform( float scale, const mat3& r33 )
120{
121        vec3 vertex_offset     = glm::vec3();
122        mat3 vertex_transform  = scale * r33;
123        mat3 normal_transform  = r33;
124
125        for ( uint32 c = 0; c < m_data->get_channel_count(); ++c )
126        {
127                const mesh_raw_channel* channel = m_data->get_channel(c);
128                const vertex_descriptor& desc   = channel->desc;
129                uint8* raw_data = channel->data;
130                int vtx_size = desc.size;
131                int p_offset = -1;
132                int n_offset = -1;
133                int t_offset = -1;
134                for ( uint32 i = 0; i < desc.count; ++i )
135                        switch ( desc.slots[i].vslot )
136                        {
137                                case slot::POSITION : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) p_offset = desc.slots[i].offset; break;
138                                case slot::NORMAL   : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) n_offset = desc.slots[i].offset; break;
139                                case slot::TANGENT  : if ( desc.slots[i].etype == FLOAT_VECTOR_4 ) t_offset = desc.slots[i].offset; break;
140                                default             : break;
141                        }
142
143                if ( p_offset != -1 )
144                        for ( uint32 i = 0; i < channel->count; i++)
145                        {
146                                vec3& p = *((vec3*)(raw_data + vtx_size*i + p_offset ));
147                                p = vertex_transform * p + vertex_offset;
148                        }
149
150                if ( n_offset != -1 )
151                        for ( uint32 i = 0; i < channel->count; i++)
152                        {
153                                vec3& n = *((vec3*)(raw_data + vtx_size*i + n_offset ));
154                                n = glm::normalize( normal_transform * n );
155                        }
156                if ( t_offset != -1 )
157                        for ( uint32 i = 0; i < channel->count; i++)
158                        {
159                                vec4& t = *((vec4*)(raw_data + vtx_size*i + t_offset ));
160                                t = vec4( glm::normalize( normal_transform * vec3(t) ), t[3] );
161                        }
162        }
163}
[294]164
165struct vertex_g
166{
167        nv::vec4 tangent;
168};
169
170void nv::mesh_data_creator::generate_tangents()
171{
172        int p_offset = -1;
173        int n_offset = -1;
174        int t_offset = -1;
175        datatype i_type = NONE;
176        uint32 n_channel_index = 0;
177
178        const mesh_raw_channel* p_channel = nullptr;
179              mesh_raw_channel* n_channel = nullptr;
180        const mesh_raw_channel* t_channel = nullptr;
181        const mesh_raw_channel* i_channel = nullptr;
182
183        for ( uint32 c = 0; c < m_data->get_channel_count(); ++c )
184        {
185                const mesh_raw_channel* channel = m_data->get_channel(c);
186                const vertex_descriptor& desc   = channel->desc;
187                for ( uint32 i = 0; i < desc.count; ++i )
188                        switch ( desc.slots[i].vslot )
189                {
190                        case slot::POSITION :
191                                if ( desc.slots[i].etype == FLOAT_VECTOR_3 )
192                                {
193                                        p_offset  = desc.slots[i].offset;
194                                        p_channel = channel;
195                                }
196                                break;
197                        case slot::NORMAL   : if ( desc.slots[i].etype == FLOAT_VECTOR_3 )
198                                {
199                                        n_offset  = desc.slots[i].offset;
200                                        n_channel = m_data->m_channels[ c ];
201                                        n_channel_index = c;
202                                }
203                                break;
204                        case slot::TEXCOORD : if ( desc.slots[i].etype == FLOAT_VECTOR_2 )
205                                {
206                                        t_offset  = desc.slots[i].offset;
207                                        t_channel = channel;
208                                }
209                                break;
210                        case slot::INDEX    :
211                                {
212                                        i_type    = desc.slots[i].etype;
213                                        i_channel = channel;
214                                }
215                                break;
216                        case slot::TANGENT  : return;
217                        default             : break;
218                }
219        }
220        if ( !p_channel || !n_channel || !t_channel ) return;
221
222        if ( p_channel->count != n_channel->count || p_channel->count % t_channel->count != 0 || ( i_type != UINT && i_type != USHORT && i_type != NONE ) )
223        {
224                return;
225        }
226
227        mesh_raw_channel* g_channel = mesh_raw_channel::create<vertex_g>( p_channel->count );
228        vec4* tangents              = (vec4*)g_channel->data;
229        vec3* tangents2             = new vec3[ p_channel->count ];
230        uint32 tri_count = i_channel ? i_channel->count / 3 : t_channel->count / 3;
231        uint32 vtx_count = p_channel->count;
232        uint32 sets      = p_channel->count / t_channel->count;
233
234        for ( unsigned int i = 0; i < tri_count; ++i )
235        {
236                uint32 ti0 = 0;
237                uint32 ti1 = 0;
238                uint32 ti2 = 0;
239                if ( i_type == UINT )
240                {
241                        const uint32* idata = (const uint32*)i_channel->data;
242                        ti0 = idata[ i * 3 ];
243                        ti1 = idata[ i * 3 + 1 ];
244                        ti2 = idata[ i * 3 + 2 ];
245                }
246                else if ( i_type == USHORT )
247                {
248                        const uint16* idata = (const uint16*)i_channel->data;
249                        ti0 = idata[ i * 3 ];
250                        ti1 = idata[ i * 3 + 1 ];
251                        ti2 = idata[ i * 3 + 2 ];
252                }
253                else // if ( i_type == NONE )
254                {
255                        ti0 = i * 3;
256                        ti1 = i * 3 + 1;
257                        ti2 = i * 3 + 2;
258                }
259
260                const vec2& w1 = *((vec2*)(t_channel->data + t_channel->desc.size*ti0 + t_offset ));
261                const vec2& w2 = *((vec2*)(t_channel->data + t_channel->desc.size*ti1 + t_offset ));
262                const vec2& w3 = *((vec2*)(t_channel->data + t_channel->desc.size*ti2 + t_offset ));
263                vec2 st1 = w3 - w1;
264                vec2 st2 = w2 - w1;
265                float stst = (st1.x * st2.y - st2.x * st1.y);
266                float coef = ( stst != 0.0f ? 1.0f / stst : 0.0f );
267
268                for ( uint32 set = 0; set < sets; ++set )
269                {
270                        uint32 nti0 = t_channel->count * set + ti0;
271                        uint32 nti1 = t_channel->count * set + ti1;
272                        uint32 nti2 = t_channel->count * set + ti2;
273                        vec3 v1 = *((vec3*)(p_channel->data + p_channel->desc.size*nti0 + p_offset ));
274                        vec3 v2 = *((vec3*)(p_channel->data + p_channel->desc.size*nti1 + p_offset ));
275                        vec3 v3 = *((vec3*)(p_channel->data + p_channel->desc.size*nti2 + p_offset ));
276                        vec3 xyz1 = v3 - v1;
277                        vec3 xyz2 = v2 - v1;
278
279                        //glm::vec3 normal = glm::cross( xyz1, xyz2 );
280                        //
281                        //vtcs[ ti0 ].normal += normal;
282                        //vtcs[ ti1 ].normal += normal;
283                        //vtcs[ ti2 ].normal += normal;
284                        vec3 tangent  = (( xyz1 * st2.y ) - ( xyz2 * st1.y )) * coef;
285                        vec3 tangent2 = (( xyz2 * st1.x ) - ( xyz1 * st2.x )) * coef;
286
287                        tangents[nti0] = vec4( vec3( tangents[nti0] ) + tangent, 0 );
288                        tangents[nti1] = vec4( vec3( tangents[nti1] ) + tangent, 0 );
289                        tangents[nti2] = vec4( vec3( tangents[nti2] ) + tangent, 0 );
290
291                        tangents2[nti0] += tangent2;
292                        tangents2[nti1] += tangent2;
293                        tangents2[nti2] += tangent2;
294                }
295        }
296
297        for ( unsigned int i = 0; i < vtx_count; ++i )
298        {
299                const vec3 n = *((vec3*)(n_channel->data + n_channel->desc.size*i + n_offset ));
300                const vec3 t = vec3(tangents[i]);
301                if ( ! ( t.x == 0.0f && t.y == 0.0f && t.z == 0.0f ) )
302                {
303                        tangents[i]    = vec4( glm::normalize(t - n * glm::dot( n, t )), 0.0f );
304                        tangents[i][3] = (glm::dot(glm::cross(n, t), tangents2[i]) < 0.0f) ? -1.0f : 1.0f;
305                }
306        }
307        delete tangents2;
308
309        m_data->m_channels[ n_channel_index ] = merge_channels( n_channel, g_channel );
310        delete n_channel;
311        delete g_channel;
312}
313
314nv::mesh_raw_channel* nv::mesh_data_creator::merge_channels( mesh_raw_channel* a, mesh_raw_channel* b )
315{
316        NV_ASSERT( a->count == b->count, "merge_channel - bad channels!" );
317        vertex_descriptor adesc = a->desc;
318        vertex_descriptor bdesc = b->desc;
319        uint32            count = a->count;
320
321        vertex_descriptor desc  = a->desc;
322        for ( uint32 i = 0; i < bdesc.count; i++ )
323        {
324                desc.slots[desc.count+i] = bdesc.slots[i];
325                desc.slots[desc.count+i].offset += desc.size;
326        }
327        desc.size  += bdesc.size;
328        desc.count += bdesc.count;
329        uint8* data = new uint8[ count * desc.size ];
330        for ( uint32 i = 0; i < count; ++i )
331        {
332                std::copy_n( a->data + i * adesc.size, adesc.size, data + i*desc.size );
333                std::copy_n( b->data + i * bdesc.size, bdesc.size, data + i*desc.size + adesc.size );
334        }
335        mesh_raw_channel* result = new mesh_raw_channel;
336        result->count = count;
337        result->desc  = desc;
338        result->data  = data;
339        return result;
340}
Note: See TracBrowser for help on using the repository browser.