URL https://opencores.org/ocsvn/2d_game_console/2d_game_console/trunk

Subversion Repositories 2d_game_console

[/] [2d_game_console/] [trunk/] [Processor_Quartus/] [Sprite_Shape_Reader.v.bak] - Blame information for rev 2

Details | Compare with Previous | View Log


module Sprite_Shape_Reader(
        clk,
        rst,
        level_counter,
        data_in,
        sprite_id,
        sprite_y,
        V_pos_in,
        H_pos_in,
 
        sprite_shape_out,
        wren_out,
        addr_out,
        level_counter_enable,
        level_counter_reset,
        EstadoAtual
);
 
 
        input clk;
        input rst;
        input   [6:0]           level_counter;
        input   [9:0]           H_pos_in;
        input   [9:0]           V_pos_in;
        input   [15:0]  data_in;
 
        input   [383:0] sprite_id;
        input   [639:0] sprite_y;
 
 
        output                  wren_out;
        output  reg     level_counter_enable;
        output  reg     level_counter_reset;
        output  reg     [15:0]  addr_out;
 
        output  [1023:0]        sprite_shape_out;
 
        reg     [5:0]   level_sprite_id;
        reg     [9:0]   level_sprite_y;
 
        reg     [1023:0]        line_A_shape;
        reg     [1023:0]        line_B_shape;
        reg                             line_flag;
 
        parameter       line_A  = 1'b0;
        parameter       line_B  = 1'b1;
 
        assign wren_out = 1'b0;
        assign sprite_shape_out = (line_flag == line_A)? line_B_shape : line_A_shape;
 
 
        /*################################################################*/
        /*############  MAQUINA DE ESTADO                                                       ############*/
        /*############                                                                                                          ############*/
        /*############  LEITURA DOS SHAPES                                                      ############*/
        /*############  SALVOS NA DATA_SEGMENT_RAM                              ############*/
        /*################################################################*/
 
        output  reg     [4:0]           EstadoAtual;
                                reg     [4:0]           EstadoFuturo;
 
        // Estados
        parameter       Reset                                           = 5'b00000;     // Reset                                                = 0
        parameter       Wait_Line                               = 5'b00001;     // Wait_Line                            = 1
        parameter       Change_Line                             = 5'b00010;     // Change_Line                          = 2
        parameter       Counter_Reset_Off               = 5'b00011;     // Counter_Reset_Off            = 3
        parameter       Get_Level_Info                  = 5'b00100;     // Get_Level_Info                       = 4
        parameter       Test_Shape                              = 5'b00101;     // Test_Shape                           = 5
        parameter       Set_Shape_Address               = 5'b00110;     // Set_Shape_Address            = 6
        parameter       Read_Shape                              = 5'b00111;     // Read_Shape                           = 7
        parameter       Change_Level                    = 5'b01000;     // Change_Level                 = 8
        parameter       Counter_Enable_Off      = 5'b01001;     // Counter_Enable_Off   = 9
        parameter       Test_Level                              = 5'b01010;     // Test_Level                           = 10
 
 
        // Decodificador de proximo estado
        always @ (V_pos_in, H_pos_in, sprite_y, level_sprite_y, level_counter, EstadoAtual)
        begin
                case (EstadoAtual)
 
                        // Estado 0
                        Reset:
                        begin
                                if(V_pos_in == 31 && H_pos_in == 0)
                                        EstadoFuturo = Wait_Line;
 
                                else
                                        EstadoFuturo = Reset;
                        end
 
                        // Estado 1
                        Wait_Line:
                        begin
                                if(V_pos_in >= 32 && V_pos_in <= 511 && H_pos_in == 0)
                                        EstadoFuturo = Change_Line;
                                else
                                        EstadoFuturo = Wait_Line;
                        end
 
                        // Estado 2
                        Change_Line:
                        begin
                                EstadoFuturo = Counter_Reset_Off;
                        end
 
                        // Estado 3
                        Counter_Reset_Off:
                        begin
                                EstadoFuturo = Get_Level_Info;
                        end
 
                        // Estado 4
                        Get_Level_Info:
                        begin
                                EstadoFuturo = Test_Shape;
                        end
 
                        // Estado 5
                        Test_Shape:
                        begin
                                if(V_pos_in >= level_sprite_y-1 && V_pos_in <= level_sprite_y+14)
                                        EstadoFuturo = Set_Shape_Address;
                                else
                                        EstadoFuturo = Change_Level;
                        end
 
                        // Estado 6
                        Set_Shape_Address:
                        begin
                                EstadoFuturo = Read_Shape;
                        end
 
                        // Estado 7
                        Read_Shape:
                        begin
                                EstadoFuturo = Change_Level;
                        end
 
                        // Estado 8
                        Change_Level:
                        begin
                                EstadoFuturo = Counter_Enable_Off;
                        end
 
                        // Estado 9
                        Counter_Enable_Off:
                        begin
                                EstadoFuturo = Test_Level;
                        end
 
                        // Estado 10
                        Test_Level:
                        begin
                                if(level_counter <= 63 && V_pos_in <= 511)
                                        EstadoFuturo = Counter_Reset_Off;
                                else if(level_counter > 63 && V_pos_in > 511)
                                        EstadoFuturo = Reset;
                                else
                                        EstadoFuturo = Wait_Line;
                        end
 
                        default:
                        begin
                                EstadoFuturo = Reset;
                        end
 
                endcase
 
        end
 
 
        // Decodificador de saida
        always @ (posedge clk)
        begin
                case (EstadoAtual)
 
                        // Estado 0
                        Reset:
                        begin
                                level_counter_enable <= 1'b0;
                                level_counter_reset <= 1'b1;
                                line_flag <= line_B;
                        end
 
                        // Estado 1
                        Wait_Line:
                        begin
                                level_counter_enable <= 1'b0;
                                level_counter_reset <= 1'b1;
                        end
 
                        // Estado 2
                        Change_Line:
                        begin
                                if (line_flag == line_A)
                                        line_flag <= line_B;
                                else
                                        line_flag <= line_A;
                        end
 
                        // Estado 3
                        Counter_Reset_Off:
                        begin
                                level_counter_enable <= 1'b0;
                                level_counter_reset <= 1'b0;
                        end
 
                        // Estado 4
                        Get_Level_Info:
                        begin
                                level_sprite_id <= sprite_id[level_counter*6 +: 6];
                                level_sprite_y <= sprite_y[level_counter*10 +: 10];
                        end
 
                        // Estado 5
                        Test_Shape:
                        begin
 
                        end
 
                        // Estado 6
                        Set_Shape_Address:
                        begin
                                addr_out <= (level_sprite_id*5'h10) + (V_pos_in - level_sprite_y + 1'b1);
                        end
 
                        // Estado 7
                        Read_Shape:
                        begin
                                if(line_flag == line_A)
                                        line_A_shape[level_counter*16 +: 16] <= data_in[15:0];
                                else
                                        line_B_shape[level_counter*16 +: 16] <= data_in[15:0];
                        end
 
                        // Estado 8
                        Change_Level:
                        begin
                                level_counter_enable <= 1'b1;
                                level_counter_reset <= 1'b0;
                        end
 
                        // Estado 9
                        Counter_Enable_Off:
                        begin
                                level_counter_enable <= 1'b0;
                                level_counter_reset <= 1'b0;
                        end
 
                        // Estado 10
                        Test_Level:
                        begin
 
                        end
 
                        default:
                        begin
                                level_counter_enable <= 1'b0;
                                level_counter_reset <= 1'b1;
                                line_flag <= line_B;
                        end
 
                endcase
        end
 
 
        // Atualizacao de registrador de estado e logica de reset
        always @ (posedge clk)
        begin
 
                if (rst)
                begin
                        EstadoAtual     <= Reset;
                end
 
                else
                begin
                        EstadoAtual     <=        EstadoFuturo;
                end
 
        end
 
        /*################################################################*/
        /*################################################################*/
 
 
 
endmodule

Browse

Tools

Subversion Repositories 2d_game_console

[/] [2d_game_console/] [trunk/] [Processor_Quartus/] [Sprite_Shape_Reader.v.bak] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	lucas.vbal	`module Sprite_Shape_Reader(`
2			`clk,`
3			`rst,`
4			`level_counter,`
5			`data_in,`
6			`sprite_id,`
7			`sprite_y,`
8			`V_pos_in,`
9			`H_pos_in,`
10
11			`sprite_shape_out,`
12			`wren_out,`
13			`addr_out,`
14			`level_counter_enable,`
15			`level_counter_reset,`
16			`EstadoAtual`
17			`);`
18
19
20			`input clk;`
21			`input rst;`
22			`input [6:0] level_counter;`
23			`input [9:0] H_pos_in;`
24			`input [9:0] V_pos_in;`
25			`input [15:0] data_in;`
26
27			`input [383:0] sprite_id;`
28			`input [639:0] sprite_y;`
29
30
31			`output wren_out;`
32			`output reg level_counter_enable;`
33			`output reg level_counter_reset;`
34			`output reg [15:0] addr_out;`
35
36			`output [1023:0] sprite_shape_out;`
37
38			`reg [5:0] level_sprite_id;`
39			`reg [9:0] level_sprite_y;`
40
41			`reg [1023:0] line_A_shape;`
42			`reg [1023:0] line_B_shape;`
43			`reg line_flag;`
44
45			`parameter line_A = 1'b0;`
46			`parameter line_B = 1'b1;`
47
48			`assign wren_out = 1'b0;`
49			`assign sprite_shape_out = (line_flag == line_A)? line_B_shape : line_A_shape;`
50
51
52			`/################################################################/`
53			`/############ MAQUINA DE ESTADO ############/`
54			`/############ ############/`
55			`/############ LEITURA DOS SHAPES ############/`
56			`/############ SALVOS NA DATA_SEGMENT_RAM ############/`
57			`/################################################################/`
58
59			`output reg [4:0] EstadoAtual;`
60			`reg [4:0] EstadoFuturo;`
61
62			`// Estados`
63			`parameter Reset = 5'b00000; // Reset = 0`
64			`parameter Wait_Line = 5'b00001; // Wait_Line = 1`
65			`parameter Change_Line = 5'b00010; // Change_Line = 2`
66			`parameter Counter_Reset_Off = 5'b00011; // Counter_Reset_Off = 3`
67			`parameter Get_Level_Info = 5'b00100; // Get_Level_Info = 4`
68			`parameter Test_Shape = 5'b00101; // Test_Shape = 5`
69			`parameter Set_Shape_Address = 5'b00110; // Set_Shape_Address = 6`
70			`parameter Read_Shape = 5'b00111; // Read_Shape = 7`
71			`parameter Change_Level = 5'b01000; // Change_Level = 8`
72			`parameter Counter_Enable_Off = 5'b01001; // Counter_Enable_Off = 9`
73			`parameter Test_Level = 5'b01010; // Test_Level = 10`
74
75
76			`// Decodificador de proximo estado`
77			`always @ (V_pos_in, H_pos_in, sprite_y, level_sprite_y, level_counter, EstadoAtual)`
78			`begin`
79			`case (EstadoAtual)`
80
81			`// Estado 0`
82			`Reset:`
83			`begin`
84			`if(V_pos_in == 31 && H_pos_in == 0)`
85			`EstadoFuturo = Wait_Line;`
86
87			`else`
88			`EstadoFuturo = Reset;`
89			`end`
90
91			`// Estado 1`
92			`Wait_Line:`
93			`begin`
94			`if(V_pos_in >= 32 && V_pos_in <= 511 && H_pos_in == 0)`
95			`EstadoFuturo = Change_Line;`
96			`else`
97			`EstadoFuturo = Wait_Line;`
98			`end`
99
100			`// Estado 2`
101			`Change_Line:`
102			`begin`
103			`EstadoFuturo = Counter_Reset_Off;`
104			`end`
105
106			`// Estado 3`
107			`Counter_Reset_Off:`
108			`begin`
109			`EstadoFuturo = Get_Level_Info;`
110			`end`
111
112			`// Estado 4`
113			`Get_Level_Info:`
114			`begin`
115			`EstadoFuturo = Test_Shape;`
116			`end`
117
118			`// Estado 5`
119			`Test_Shape:`
120			`begin`
121			`if(V_pos_in >= level_sprite_y-1 && V_pos_in <= level_sprite_y+14)`
122			`EstadoFuturo = Set_Shape_Address;`
123			`else`
124			`EstadoFuturo = Change_Level;`
125			`end`
126
127			`// Estado 6`
128			`Set_Shape_Address:`
129			`begin`
130			`EstadoFuturo = Read_Shape;`
131			`end`
132
133			`// Estado 7`
134			`Read_Shape:`
135			`begin`
136			`EstadoFuturo = Change_Level;`
137			`end`
138
139			`// Estado 8`
140			`Change_Level:`
141			`begin`
142			`EstadoFuturo = Counter_Enable_Off;`
143			`end`
144
145			`// Estado 9`
146			`Counter_Enable_Off:`
147			`begin`
148			`EstadoFuturo = Test_Level;`
149			`end`
150
151			`// Estado 10`
152			`Test_Level:`
153			`begin`
154			`if(level_counter <= 63 && V_pos_in <= 511)`
155			`EstadoFuturo = Counter_Reset_Off;`
156			`else if(level_counter > 63 && V_pos_in > 511)`
157			`EstadoFuturo = Reset;`
158			`else`
159			`EstadoFuturo = Wait_Line;`
160			`end`
161
162			`default:`
163			`begin`
164			`EstadoFuturo = Reset;`
165			`end`
166
167			`endcase`
168
169			`end`
170
171
172			`// Decodificador de saida`
173			`always @ (posedge clk)`
174			`begin`
175			`case (EstadoAtual)`
176
177			`// Estado 0`
178			`Reset:`
179			`begin`
180			`level_counter_enable <= 1'b0;`
181			`level_counter_reset <= 1'b1;`
182			`line_flag <= line_B;`
183			`end`
184
185			`// Estado 1`
186			`Wait_Line:`
187			`begin`
188			`level_counter_enable <= 1'b0;`
189			`level_counter_reset <= 1'b1;`
190			`end`
191
192			`// Estado 2`
193			`Change_Line:`
194			`begin`
195			`if (line_flag == line_A)`
196			`line_flag <= line_B;`
197			`else`
198			`line_flag <= line_A;`
199			`end`
200
201			`// Estado 3`
202			`Counter_Reset_Off:`
203			`begin`
204			`level_counter_enable <= 1'b0;`
205			`level_counter_reset <= 1'b0;`
206			`end`
207
208			`// Estado 4`
209			`Get_Level_Info:`
210			`begin`
211			`level_sprite_id <= sprite_id[level_counter*6 +: 6];`
212			`level_sprite_y <= sprite_y[level_counter*10 +: 10];`
213			`end`
214
215			`// Estado 5`
216			`Test_Shape:`
217			`begin`
218
219			`end`
220
221			`// Estado 6`
222			`Set_Shape_Address:`
223			`begin`
224			`addr_out <= (level_sprite_id*5'h10) + (V_pos_in - level_sprite_y + 1'b1);`
225			`end`
226
227			`// Estado 7`
228			`Read_Shape:`
229			`begin`
230			`if(line_flag == line_A)`
231			`line_A_shape[level_counter*16 +: 16] <= data_in[15:0];`
232			`else`
233			`line_B_shape[level_counter*16 +: 16] <= data_in[15:0];`
234			`end`
235
236			`// Estado 8`
237			`Change_Level:`
238			`begin`
239			`level_counter_enable <= 1'b1;`
240			`level_counter_reset <= 1'b0;`
241			`end`
242
243			`// Estado 9`
244			`Counter_Enable_Off:`
245			`begin`
246			`level_counter_enable <= 1'b0;`
247			`level_counter_reset <= 1'b0;`
248			`end`
249
250			`// Estado 10`
251			`Test_Level:`
252			`begin`
253
254			`end`
255
256			`default:`
257			`begin`
258			`level_counter_enable <= 1'b0;`
259			`level_counter_reset <= 1'b1;`
260			`line_flag <= line_B;`
261			`end`
262
263			`endcase`
264			`end`
265
266
267			`// Atualizacao de registrador de estado e logica de reset`
268			`always @ (posedge clk)`
269			`begin`
270
271			`if (rst)`
272			`begin`
273			`EstadoAtual <= Reset;`
274			`end`
275
276			`else`
277			`begin`
278			`EstadoAtual <= EstadoFuturo;`
279			`end`
280
281			`end`
282
283			`/################################################################/`
284			`/################################################################/`
285
286
287
288			`endmodule`