1#include "rs_core.rsh"
2#include "rs_graphics.rsh"
3#include "rs_structs.h"
4
5/* Function declarations from libRS */
6extern float4 __attribute__((overloadable)) convert_float4(uchar4 c);
7
8/* Implementation of Core Runtime */
9
10/*
11extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float r, float g, float b)
12{
13    uchar4 c;
14    c.x = (uchar)(r * 255.f + 0.5f);
15    c.y = (uchar)(g * 255.f + 0.5f);
16    c.z = (uchar)(b * 255.f + 0.5f);
17    c.w = 255;
18    return c;
19}
20
21extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float r, float g, float b, float a)
22{
23    uchar4 c;
24    c.x = (uchar)(r * 255.f + 0.5f);
25    c.y = (uchar)(g * 255.f + 0.5f);
26    c.z = (uchar)(b * 255.f + 0.5f);
27    c.w = (uchar)(a * 255.f + 0.5f);
28    return c;
29}
30
31extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float3 color)
32{
33    color *= 255.f;
34    color += 0.5f;
35    uchar4 c = {color.x, color.y, color.z, 255};
36    return c;
37}
38
39extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float4 color)
40{
41    color *= 255.f;
42    color += 0.5f;
43    uchar4 c = {color.x, color.y, color.z, color.w};
44    return c;
45}
46*/
47
48extern float4 rsUnpackColor8888(uchar4 c)
49{
50    float4 ret = (float4)0.003921569f;
51    ret *= convert_float4(c);
52    return ret;
53}
54
55/////////////////////////////////////////////////////
56// Matrix ops
57/////////////////////////////////////////////////////
58
59extern void __attribute__((overloadable))
60rsMatrixSet(rs_matrix4x4 *m, uint32_t row, uint32_t col, float v) {
61    m->m[row * 4 + col] = v;
62}
63
64extern float __attribute__((overloadable))
65rsMatrixGet(const rs_matrix4x4 *m, uint32_t row, uint32_t col) {
66    return m->m[row * 4 + col];
67}
68
69extern void __attribute__((overloadable))
70rsMatrixSet(rs_matrix3x3 *m, uint32_t row, uint32_t col, float v) {
71    m->m[row * 3 + col] = v;
72}
73
74extern float __attribute__((overloadable))
75rsMatrixGet(const rs_matrix3x3 *m, uint32_t row, uint32_t col) {
76    return m->m[row * 3 + col];
77}
78
79extern void __attribute__((overloadable))
80rsMatrixSet(rs_matrix2x2 *m, uint32_t row, uint32_t col, float v) {
81    m->m[row * 2 + col] = v;
82}
83
84extern float __attribute__((overloadable))
85rsMatrixGet(const rs_matrix2x2 *m, uint32_t row, uint32_t col) {
86    return m->m[row * 2 + col];
87}
88
89/*
90extern float4 __attribute__((overloadable))
91rsMatrixMultiply(const rs_matrix4x4 *m, float4 in) {
92    float4 ret;
93    ret.x = (m->m[0] * in.x) + (m->m[4] * in.y) + (m->m[8] * in.z) + (m->m[12] * in.w);
94    ret.y = (m->m[1] * in.x) + (m->m[5] * in.y) + (m->m[9] * in.z) + (m->m[13] * in.w);
95    ret.z = (m->m[2] * in.x) + (m->m[6] * in.y) + (m->m[10] * in.z) + (m->m[14] * in.w);
96    ret.w = (m->m[3] * in.x) + (m->m[7] * in.y) + (m->m[11] * in.z) + (m->m[15] * in.w);
97    return ret;
98}
99extern float4 __attribute__((overloadable))
100rsMatrixMultiply(rs_matrix4x4 *m, float4 in) {
101    return rsMatrixMultiply((const rs_matrix4x4 *)m, in);
102}
103
104extern float4 __attribute__((overloadable))
105rsMatrixMultiply(const rs_matrix4x4 *m, float3 in) {
106    float4 ret;
107    ret.x = (m->m[0] * in.x) + (m->m[4] * in.y) + (m->m[8] * in.z) + m->m[12];
108    ret.y = (m->m[1] * in.x) + (m->m[5] * in.y) + (m->m[9] * in.z) + m->m[13];
109    ret.z = (m->m[2] * in.x) + (m->m[6] * in.y) + (m->m[10] * in.z) + m->m[14];
110    ret.w = (m->m[3] * in.x) + (m->m[7] * in.y) + (m->m[11] * in.z) + m->m[15];
111    return ret;
112}
113extern float4 __attribute__((overloadable))
114rsMatrixMultiply(rs_matrix4x4 *m, float3 in) {
115    return rsMatrixMultiply((const rs_matrix4x4 *)m, in);
116}
117
118extern float4 __attribute__((overloadable))
119rsMatrixMultiply(const rs_matrix4x4 *m, float2 in) {
120    float4 ret;
121    ret.x = (m->m[0] * in.x) + (m->m[4] * in.y) + m->m[12];
122    ret.y = (m->m[1] * in.x) + (m->m[5] * in.y) + m->m[13];
123    ret.z = (m->m[2] * in.x) + (m->m[6] * in.y) + m->m[14];
124    ret.w = (m->m[3] * in.x) + (m->m[7] * in.y) + m->m[15];
125    return ret;
126}
127extern float4 __attribute__((overloadable))
128rsMatrixMultiply(rs_matrix4x4 *m, float2 in) {
129    return rsMatrixMultiply((const rs_matrix4x4 *)m, in);
130}
131
132extern float3 __attribute__((overloadable))
133rsMatrixMultiply(const rs_matrix3x3 *m, float3 in) {
134    float3 ret;
135    ret.x = (m->m[0] * in.x) + (m->m[3] * in.y) + (m->m[6] * in.z);
136    ret.y = (m->m[1] * in.x) + (m->m[4] * in.y) + (m->m[7] * in.z);
137    ret.z = (m->m[2] * in.x) + (m->m[5] * in.y) + (m->m[8] * in.z);
138    return ret;
139}
140extern float3 __attribute__((overloadable))
141rsMatrixMultiply(rs_matrix3x3 *m, float3 in) {
142    return rsMatrixMultiply((const rs_matrix3x3 *)m, in);
143}
144
145extern float3 __attribute__((overloadable))
146rsMatrixMultiply(const rs_matrix3x3 *m, float2 in) {
147    float3 ret;
148    ret.x = (m->m[0] * in.x) + (m->m[3] * in.y);
149    ret.y = (m->m[1] * in.x) + (m->m[4] * in.y);
150    ret.z = (m->m[2] * in.x) + (m->m[5] * in.y);
151    return ret;
152}
153extern float3 __attribute__((overloadable))
154rsMatrixMultiply(rs_matrix3x3 *m, float2 in) {
155    return rsMatrixMultiply((const rs_matrix3x3 *)m, in);
156}
157*/
158
159extern float2 __attribute__((overloadable))
160rsMatrixMultiply(const rs_matrix2x2 *m, float2 in) {
161    float2 ret;
162    ret.x = (m->m[0] * in.x) + (m->m[2] * in.y);
163    ret.y = (m->m[1] * in.x) + (m->m[3] * in.y);
164    return ret;
165}
166extern float2 __attribute__((overloadable))
167rsMatrixMultiply(rs_matrix2x2 *m, float2 in) {
168    return rsMatrixMultiply((const rs_matrix2x2 *)m, in);
169}
170
171