OpenCores
URL https://opencores.org/ocsvn/orsoc_graphics_accelerator/orsoc_graphics_accelerator/trunk

Subversion Repositories orsoc_graphics_accelerator

[/] [orsoc_graphics_accelerator/] [trunk/] [sw/] [drivers/] [gfx/] [bare/] [orgfx_3d.c] - Blame information for rev 5

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 5 maiden 
/*
2 
Bare metal OpenCores GFX IP driver for Wishbone bus.
3 
 
4 
Anton Fosselius, Per Lenander 2012
5 
  */
6 
 
7 
#include "orgfx_3d.h"
8 
#include "orgfx.h"
9 
 
10 
#include <math.h>
11 
 
12 
orgfx_matrix orgfx3d_identity(void)
13 
{
14 
    orgfx_matrix i;
15 
    i.aa = i.bb = i.cc = 1;
16 
    i.ab = i.ac = i.ba = i.bc = i.ca = i.cb = 0;
17 
    i.tx = i.ty = i.tz = 0;
18 
    return i;
19 
}
20 
 
21 
orgfx_matrix orgfx3d_rotateX(orgfx_matrix mat, float rad)
22 
{
23 
    orgfx_matrix ret = mat;
24 
 
25 
    float sinrad = sin(rad);
26 
    float cosrad = cos(rad);
27 
 
28 
    //ret.aa = mat.aa
29 
    ret.ab = mat.ab*cosrad - mat.ac*sinrad;
30 
    ret.ac = mat.ab*sinrad + mat.ac*cosrad;
31 
    //ret.ba = mat.ba
32 
    ret.bb = mat.bb*cosrad - mat.bc*sinrad;
33 
    ret.bc = mat.bb*sinrad + mat.bc*cosrad;
34 
    //ret.ca = mat.ca
35 
    ret.cb = mat.cb*cosrad - mat.cc*sinrad;
36 
    ret.cc = mat.cb*sinrad + mat.cc*cosrad;
37 
    //ret.tx = mat.tx
38 
    ret.ty = mat.ty*cosrad - mat.tz*sinrad;
39 
    ret.tz = mat.ty*sinrad + mat.tz*cosrad;
40 
    return ret;
41 
}
42 
 
43 
orgfx_matrix orgfx3d_rotateY(orgfx_matrix mat, float rad)
44 
{
45 
    orgfx_matrix ret = mat;
46 
 
47 
    float sinrad = sin(rad);
48 
    float cosrad = cos(rad);
49 
 
50 
    ret.aa = mat.aa*cosrad + mat.ac*sinrad;
51 
    //ret.ab = mat.ab
52 
    ret.ac = -mat.aa*sinrad + mat.ac*cosrad;
53 
    ret.ba = mat.ba*cosrad + mat.bc*sinrad;
54 
    //ret.bb = mat.bb
55 
    ret.bc = -mat.ba*sinrad + mat.bc*cosrad;
56 
    ret.ca = mat.ca*cosrad + mat.cc*sinrad;
57 
    //ret.cb = mat.cb
58 
    ret.cc = -mat.ca*sinrad + mat.cc*cosrad;
59 
    ret.tx = mat.tx*cosrad + mat.tz*sinrad;
60 
    //ret.ty = mat.ty
61 
    ret.tz = -mat.tx*sinrad + mat.tz*cosrad;
62 
    return ret;
63 
}
64 
 
65 
orgfx_matrix orgfx3d_rotateZ(orgfx_matrix mat, float rad)
66 
{
67 
    orgfx_matrix ret = mat;
68 
 
69 
    float sinrad = sin(rad);
70 
    float cosrad = cos(rad);
71 
 
72 
    ret.aa = mat.aa*cosrad - mat.ab*sinrad;
73 
    ret.ab = mat.aa*sinrad + mat.ab*cosrad;
74 
    //ret.ac = mat.ac
75 
    ret.ba = mat.ba*cosrad - mat.bb*sinrad;
76 
    ret.bb = mat.ba*sinrad + mat.bb*cosrad;
77 
    //ret.bc = mat.bc
78 
    ret.ca = mat.ca*cosrad - mat.cb*sinrad;
79 
    ret.cb = mat.ca*sinrad + mat.cb*cosrad;
80 
    //ret.cc = mat.cc
81 
    ret.tx = mat.tx*cosrad - mat.ty*sinrad;
82 
    ret.ty = mat.tx*sinrad + mat.ty*cosrad;
83 
    //ret.tz = mat.tz
84 
    return ret;
85 
}
86 
 
87 
orgfx_matrix orgfx3d_scale(orgfx_matrix mat, orgfx_point3 s)
88 
{
89 
    orgfx_matrix ret = mat;
90 
    ret.aa *= s.x;
91 
    ret.ab *= s.x;
92 
    ret.ac *= s.x;
93 
    ret.tx *= s.x;
94 
    ret.ba *= s.y;
95 
    ret.bb *= s.y;
96 
    ret.bc *= s.y;
97 
    ret.ty *= s.y;
98 
    ret.ca *= s.z;
99 
    ret.cb *= s.z;
100 
    ret.cc *= s.z;
101 
    ret.tz *= s.z;
102 
    return ret;
103 
}
104 
 
105 
orgfx_matrix orgfx3d_translate(orgfx_matrix mat, orgfx_point3 t)
106 
{
107 
    orgfx_matrix ret = mat;
108 
    ret.tx += t.x;
109 
    ret.ty += t.y;
110 
    ret.tz += t.z;
111 
    return ret;
112 
}
113 
 
114 
void orgfx3d_set_matrix(orgfx_matrix mat)
115 
{
116 
    orgfx_set_transformation_matrix(mat.aa*FIXEDW, mat.ab*FIXEDW, mat.ac*FIXEDW, mat.tx*FIXEDW,
117 
                                    mat.ba*FIXEDW, mat.bb*FIXEDW, mat.bc*FIXEDW, mat.ty*FIXEDW,
118 
                                    mat.ca*FIXEDW, mat.cb*FIXEDW, mat.cc*FIXEDW, mat.tz*FIXEDW);
119 
}
120 
 
121 
orgfx_mesh orgfx3d_make_mesh(orgfx_face* faces,
122 
                             unsigned int nFaces,
123 
                             orgfx_point3* verts,
124 
                             unsigned int nVerts,
125 
                             orgfx_point2* uvs,
126 
                             unsigned int nUvs)
127 
{
128 
    orgfx_mesh mesh;
129 
    mesh.numFaces = nFaces;
130 
    mesh.numVerts = nVerts;
131 
    mesh.numUvs = nUvs;
132 
    mesh.translation.x = mesh.translation.y = mesh.translation.z = 0.0;
133 
    mesh.rotation.x = mesh.rotation.y = mesh.rotation.z = 0.0;
134 
    mesh.scale.x = mesh.scale.y = mesh.scale.z = 1.0;
135 
    mesh.faces = faces;
136 
    mesh.verts = verts;
137 
    mesh.uvs = uvs;
138 
    return mesh;
139 
}
140 
 
141 
void orgfx3d_mesh_texture_size(orgfx_mesh* mesh,
142 
                               unsigned int width,
143 
                               unsigned int height)
144 
{
145 
    orgfx_point2 *uvs = mesh->uvs;
146 
    unsigned int numUvs = mesh->numUvs;
147 
 
148 
    unsigned int i;
149 
    for(i = 0; i < numUvs; i++)
150 
    {
151 
        uvs[i].x *= width;
152 
        uvs[i].y = 1.0 - uvs[i].y; // Mirror v coordinate
153 
        uvs[i].y *= height;
154 
    }
155 
}
156 
 
157 
void orgfx3d_draw_mesh(orgfx_mesh *mesh, int filled, int textured)
158 
{
159 
    if(textured)
160 
        orgfx_enable_tex0(1);
161 
    else
162 
        orgfx_enable_tex0(0);
163 
 
164 
    orgfx_enable_transform(1);
165 
 
166 
    orgfx_matrix m = orgfx3d_identity();
167 
    m = orgfx3d_rotateX(m, mesh->rotation.x);
168 
    m = orgfx3d_rotateY(m, mesh->rotation.y);
169 
    m = orgfx3d_rotateZ(m, mesh->rotation.z);
170 
    m = orgfx3d_scale(m, mesh->scale);
171 
    m = orgfx3d_translate(m, mesh->translation);
172 
    orgfx3d_set_matrix(m);
173 
 
174 
    int f;
175 
    for(f = 0; f < mesh->numFaces; f++)
176 
    {
177 
        orgfx_point3 p1 = mesh->verts[mesh->faces[f].p1];
178 
        orgfx_point3 p2 = mesh->verts[mesh->faces[f].p2];
179 
        orgfx_point3 p3 = mesh->verts[mesh->faces[f].p3];
180 
 
181 
        // Handle coloring
182 
        if(textured)
183 
        {
184 
            orgfx_point2 uv1 = mesh->uvs[mesh->faces[f].uv1];
185 
            orgfx_point2 uv2 = mesh->uvs[mesh->faces[f].uv2];
186 
            orgfx_point2 uv3 = mesh->uvs[mesh->faces[f].uv3];
187 
 
188 
            orgfx_uv(uv1.x, uv1.y,
189 
                     uv2.x, uv2.y,
190 
                     uv3.x, uv3.y);
191 
        }
192 
        else
193 
        {
194 
            orgfx_set_colors(mesh->faces[f].color1,
195 
                             mesh->faces[f].color2,
196 
                             mesh->faces[f].color3);
197 
        }
198 
 
199 
        if(filled)
200 
            orgfx_triangle3d(p1.x*FIXEDW, p1.y*FIXEDW, p1.z*FIXEDW,
201 
                             p2.x*FIXEDW, p2.y*FIXEDW, p2.z*FIXEDW,
202 
                             p3.x*FIXEDW, p3.y*FIXEDW, p3.z*FIXEDW,
203 
                             1);
204 
        else
205 
        {
206 
            orgfx_line3d(p1.x*FIXEDW, p1.y*FIXEDW, p1.z*FIXEDW, p2.x*FIXEDW, p2.y*FIXEDW, p2.z*FIXEDW);
207 
            orgfx_line3d(p2.x*FIXEDW, p2.y*FIXEDW, p2.z*FIXEDW, p3.x*FIXEDW, p3.y*FIXEDW, p3.z*FIXEDW);
208 
            orgfx_line3d(p3.x*FIXEDW, p3.y*FIXEDW, p3.z*FIXEDW, p1.x*FIXEDW, p1.y*FIXEDW, p1.z*FIXEDW);
209 
        }
210 
    }
211 
 
212 
    orgfx_enable_transform(0);
213 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.