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