#include "stm32f4xx.h"

#include "arm_math.h"

#include "stm32f429i_discovery.h"

#include "stm32f429i_discovery_lcd.h"

#include "stm32f429i_discovery_l3gd20.h"

#include <r3dfb.h>

#include <r3d.h>

#include <string.h>

#include <stdio.h>

static char *itoa(int value, char* result, int base);

// vertex format

typedef struct {

uint16_t x, y, z;

uint8_t nx, ny, nz;

uint8_t u, v;

} vertex_t;

// meshes:

#include "teapot.h"

#include "box.h"

#include "pony.h"

// textures:

#include "nyan.h"

#include "box_texture.h"

#include "twilight.h"

static const r3d_drawcall_t meshes[] = {

{ R3D_PRIMITIVE_TYPE_TRIANGLES, vertices0,

sizeof(vertex_t), sizeof(vertices0) / sizeof(vertex_t), 0 },

{ R3D_PRIMITIVE_TYPE_TRIANGLES, vertices1,

sizeof(vertex_t), sizeof(vertices1) / sizeof(vertex_t), 0 },

{ R3D_PRIMITIVE_TYPE_TRIANGLES, vertices2,

sizeof(vertex_t), sizeof(vertices2) / sizeof(vertex_t), 0 },

};

static const r3d_primitive_winding_t windings[] = {

R3D_PRIMITIVE_WINDING_CW,

R3D_PRIMITIVE_WINDING_CCW,

R3D_PRIMITIVE_WINDING_CCW

};

static const r3d_texture_t *textures[] = {

(r3d_texture_t *) &nyan,

(r3d_texture_t *) &box_texture,

(r3d_texture_t *) &twilight

};

// simulation stuff

static float time = 0.0f, frametime = 0.0f;

static uint32_t fps = 0;

static uint8_t fps_str[8] = "? FPS";

static uint8_t info_str[16];

static mat4_t model, view, projection, mv, mvp;

static int mesh = 0;

static float axes[3] = {0};

// shader

typedef struct {

vec3_t position;

vec3_t normal;

vec2_t uv;

} vs_to_fs_t;

typedef struct{

//point light or directional light?

int point;

vec3_t position;

//light intensity can be greater than 1.0f

vec3_t color;

} light_t;

static light_t lights[]={

{.point=0, .position={ .x=-0.577350269f, .y=0.577350269f, .z=0.577350269f }, .color={.r=0.8f, .g=0.8f, .b=0.0f}},

{.point=0, .position={ .x=0.577350269f, .y=-0.577350269f, .z=0.577350269f }, .color={.r=0.0f, .g=0.8f, .b=0.8f}}

};

static void vertex_shader(const vertex_t *in, vs_to_fs_t *out)

{

// decode vertex

const vec3_t pc = { 0.5f, 0.5f, 0.5f }, nc = { 1.0f, 1.0f, 1.0f };

const float pi = 1.0f / 65535.0f, ni = 2.0f / 255.0f, uvi = 1.0f / 255.0f;

vec3_t position = vec3_sub(vec3_mul(vec3(in->x, in->y, in->z), pi), pc);

vec3_t normal = vec3_sub(vec3_mul(vec3(in->nx, in->ny, in->nz), ni), nc);

vec2_t uv = vec2_mul(vec2(in->u, in->v), uvi);

// transform vertex

out->position = mat4_transform_position(mvp, position);

out->normal = mat4_transform_vector(mv, normal);

out->uv = uv;

}

static vec4_t fragment_shader(const vs_to_fs_t *in)

{

vec3_t result = { 0, 0, 0 };

//eye position

const vec3_t E = { 0, 0, 1 };

const float ambient = 0.05f;

float diffuse, specular;

vec3_t N = vec3_normalize(in->normal);

int i;

for(i=0; i<sizeof(lights)/sizeof(light_t); i++){

vec3_t H = vec3_normalize(vec3_add(E, lights[i].position));

diffuse = vec3_dot(N, lights[i].position);

specular = vec3_dot(N, H);

specular *= specular;

specular *= specular;

specular *= specular;

specular *= specular;

specular *= specular;

specular *= specular * 0.6f;

vec3_t c = r3d_texture_nearest(textures[mesh], in->uv); // read texel

result.r += diffuse * c.r * lights[i].color.r + specular;

result.g += diffuse * c.g * lights[i].color.g + specular;

result.b += diffuse * c.b * lights[i].color.b + specular;

}

return vec4(ambient + result.r, ambient + result.g, ambient + result.b, 1.0f);

}

static r3d_shader_t shader = {

(r3d_vertexshader_func)vertex_shader,

(r3d_fragmentshader_func)fragment_shader,

sizeof(vs_to_fs_t) / sizeof(float)

};

static void init(void)

{

STM_EVAL_PBInit(BUTTON_USER, BUTTON_MODE_GPIO);

r3dfb_init();

LCD_SetColors(0x0000, 0xffff);

LCD_SetFont(&Font8x8);

itoa(meshes[mesh].count / 3, info_str, 10);

strcat(info_str, " tris");

r3d_viewport(1, 1, R3DFB_PIXEL_WIDTH - 1, R3DFB_PIXEL_HEIGHT - 1);

r3d_backface_culling = R3D_ENABLE;

r3d_primitive_winding = windings[mesh];

projection = mat4_perspective(60.0f, (float)R3DFB_PIXEL_WIDTH / (float)R3DFB_PIXEL_HEIGHT, 0.5f, 5.0f);

view = mat4_lookat(vec3(0.0f, 0.25f, 1.5f), vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f));

L3GD20_InitTypeDef L3GD20_InitStructure;

L3GD20_InitStructure.Power_Mode = L3GD20_MODE_ACTIVE;

L3GD20_InitStructure.Output_DataRate = L3GD20_OUTPUT_DATARATE_1;

L3GD20_InitStructure.Axes_Enable = L3GD20_AXES_ENABLE;

L3GD20_InitStructure.Band_Width = L3GD20_BANDWIDTH_4;

L3GD20_InitStructure.BlockData_Update = L3GD20_BlockDataUpdate_Continous;

L3GD20_InitStructure.Endianness = L3GD20_BLE_LSB;

L3GD20_InitStructure.Full_Scale = L3GD20_FULLSCALE_250;

L3GD20_Init(&L3GD20_InitStructure);

L3GD20_FilterConfigTypeDef L3GD20_FilterStructure;

L3GD20_FilterStructure.HighPassFilter_Mode_Selection = L3GD20_HPM_NORMAL_MODE_RES;

L3GD20_FilterStructure.HighPassFilter_CutOff_Frequency = L3GD20_HPFCF_0;

L3GD20_FilterConfig(&L3GD20_FilterStructure);

L3GD20_FilterCmd(L3GD20_HIGHPASSFILTER_ENABLE);

}

static void update(void)

{

uint8_t tmp[6] = {0};

int16_t a[3] = {0};

uint8_t tmpreg = 0;

L3GD20_Read(&tmpreg, L3GD20_CTRL_REG4_ADDR, 1);

L3GD20_Read(tmp, L3GD20_OUT_X_L_ADDR, 6);

/* check in the control register 4 the data alignment (Big Endian or Little Endian)*/

if (!(tmpreg & 0x40)) {

for (int i = 0; i < 3; i++)

a[i] = (int16_t)(((uint16_t)tmp[2 * i + 1] << 8) | (uint16_t)tmp[2 * i]);

} else {

for (int i = 0; i < 3; i++)

a[i] = (int16_t)(((uint16_t)tmp[2 * i] << 8) | (uint16_t)tmp[2 * i + 1]);

}

if (STM_EVAL_PBGetState(BUTTON_USER)) {

mesh = (mesh + 1) % 3; // next mesh

r3d_primitive_winding = windings[mesh];

itoa(meshes[mesh].count / 3, info_str, 10);

strcat(info_str, " tris");

while (STM_EVAL_PBGetState(BUTTON_USER)); // debounce

}

float delta = frametime - time;

frametime = time; // make frametime a consistent time value during the frames

for (int i = 0; i < 3; i++)

axes[i] += (float)a[i] * delta / 114.285f;

if (axes[0] < 0) axes[0] = 0;

if (axes[0] > 180) axes[0] = 180;

model = mat4_mul(

mat4_rotation(axes[0], vec3(1.0f, 0.0f, 0.0f)),

mat4_rotation(axes[1], vec3(0.0f, 1.0f, 0.0f)));

if (mesh == 1) model = mat4_mul(model, mat4_scaling(vec3(0.5f, 0.5f, 0.5f)));

mv = mat4_mul(view, model);

mvp = mat4_mul(projection, mv);

}

static void render(void)

{

r3dfb_clear();

r3d_shader = shader;

r3d_draw(&meshes[mesh]);

LCD_DisplayStringLine(LCD_LINE_1, info_str);

LCD_DisplayStringLine(LCD_LINE_3, fps_str);

char str[16] = "X: ";

itoa(axes[0], str + 3, 10);

LCD_DisplayStringLine(LCD_LINE_5, str);

str[0] = 'Y';

itoa(axes[1], str + 3, 10);

LCD_DisplayStringLine(LCD_LINE_6, str);

str[0] = 'Z';

itoa(axes[2], str + 3, 10);

LCD_DisplayStringLine(LCD_LINE_7, str);

r3dfb_swap_buffers();

fps++;

}

int main(void)

{

SysTick_Config(SystemCoreClock / 100); // SysTick event each 10ms

init();

while (1) {

update();

render();

}

}

static char* itoa(int value, char* result, int base)

{

if (base < 2 || base > 36) {

*result = '\0';

return result;

}

char *ptr = result, *ptr1 = result, tmp_char;

int tmp_value;

do {

tmp_value = value;

value /= base;

*ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" [35 + (tmp_value - value * base)];

} while (value);

if (tmp_value < 0) *ptr++ = '-';

*ptr-- = '\0';

while (ptr1 < ptr) {

tmp_char = *ptr;

*ptr-- = *ptr1;

*ptr1++ = tmp_char;

}

return result;

}

uint32_t fps_countdown = 100;

void OnSysTick(void)

{

if (--fps_countdown == 0) {

itoa(fps, fps_str, 10);

strcat(fps_str, " FPS");

fps = 0;

fps_countdown = 100;

}

time += 0.01f;

}

uint32_t L3GD20_TIMEOUT_UserCallback(void)

{

return 0;

}

#ifdef USE_FULL_ASSERT

void assert_failed(uint8_t* file, uint32_t line)

{

/* printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

while (1) { }

}

#endif