LINUX.ORG.RU

На каком яп можно так же легко и просто манипулировать пикселями?

 , ,


1

2

В процессе поисков яп для некоторых задач узнал про https://processing.org/, вопрос в заголовке. Нужно примерно такое https://i.imgur.com/Yy6BNwC.png то есть короткий, легкий для понимания код. В принципе processing устраивает, но вдруг есть какой-то искомый яп, с заданными хотелками, без vm java, достаточно производительный и такой же простой? Можно и не очень простой, если выбора совсем нет.Желательно без адовых портянок инициализации графики. Пример на скриншоте запущен на intel q6600. Сори за виндовс. Если накидаете аналог моего примера на предложенном вами яп, то вообще будет здорово!

void setup() {
  size(640, 480);
  //frameRate(60);
  background(0); 
}

void draw() {
  int stMillis = millis();
  
  for (int x = 0; x < width; x++) {
    for (int y = 0; y < height; y++) {
      if((int)random(2)==1) set(x, y, color(255,255,255));
      else set(x, y, color(0,0,0));
    }
  }
  
  float fps = 1000.0/float((millis() - stMillis));
  fill(0, 0, 0);
  rect(2, 2, 140, 35);
  fill(255, 50, 50);
  textSize(32);
  text(fps, 5, 30);
}

Кому интересно, вот что транслируется из примера выше в *.java:

import processing.core.*; 
import processing.data.*; 
import processing.event.*; 
import processing.opengl.*; 

import java.util.HashMap; 
import java.util.ArrayList; 
import java.io.File; 
import java.io.BufferedReader; 
import java.io.PrintWriter; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.io.IOException; 

public class noise extends PApplet {

public void setup() {
  
  //frameRate(60);
  background(0); 
}

public void draw() {
  int stMillis = millis();
  
  for (int x = 0; x < width; x++) {
    for (int y = 0; y < height; y++) {
      if((int)random(2)==1) set(x, y, color(255,255,255));
      else set(x, y, color(0,0,0));
    }
  }
  
  float fps = 1000.0f/PApplet.parseFloat((millis() - stMillis));
  fill(0, 0, 0);
  rect(2, 2, 140, 35);
  fill(255, 50, 50);
  textSize(32);
  text(fps, 5, 30);
}
  public void settings() {  size(640, 480); }
  static public void main(String[] passedArgs) {
    String[] appletArgs = new String[] { "noise" };
    if (passedArgs != null) {
      PApplet.main(concat(appletArgs, passedArgs));
    } else {
      PApplet.main(appletArgs);
    }
  }
}

Это же трындец сколько импортов всяких писать! Ну и если бы писал на чисто java без import processing думаю было бы все не так просто.

Ответ на: комментарий от Lorovec

но разрывы какие-то

Потому что функция основана на линейном конгруэнтном генераторе, и по факту берёт последний бит. Генератор в основе сам по себе не очень-то хороший, а младшие биты результата у него вообще ужасны. Вот оттуда и полосы. Бери нормальный генератор.

i-rinat ★★★★★
()
Ответ на: комментарий от i-rinat

Ясно, я что-то такое предполагал. Вспомнился генератор псевдо-случайных чисел б3-34 для которого даже точную формулу вывели. На java генератор лучше?

Lorovec
() автор топика

Ещё можно глянуть Corange там есть api для работы с RGBA картинками, пишешь в тексель

image_set(img,vec2_new(100,100),vec4_red());

задаёшь изображение в текстуру

texture_set_image(tex,img)

передаёшь текстуру в ui_rectangle и у тебя рисуется всё. Если хочется то можно GLSL написать и уже им рисовать.

Ну это поверхностно, с нуля там ковыряться надо долго

LINUX-ORG-RU ★★★★★
()
Ответ на: комментарий от Lorovec

На java генератор лучше?

Это надо в исходники её смотреть. Наверняка что-нибудь аналогичное. Возможно, они выбрасывают заведомо плохие биты.

i-rinat ★★★★★
()
Ответ на: комментарий от LINUX-ORG-RU

с нуля там ковыряться надо долго

Не хотелось бы. Но спасибо, всё равно посмотрю.

Lorovec
() автор топика
Ответ на: комментарий от Lorovec

Хочется скорости придётся распаралеливать openmp или glsl, на CPU миллионы текселей обрабатывать накладно, ну и рандом надо альтернативный тогда если прямо noise нужен, на ЦП у меня Сorange выдаёт при 800x600 обрабатываемом изображении 25 fps на одном ядре без всего https://imgur.com/a/ljUJ6qK, я бы ща на glsl сделал но пора спать =) А так на цп что бы ты не взял в циклах просто крутить всё будет одно и тоже +/-, а в некоторых случаях ещё и медленнее для накладных расходов типа перезаписи текстуры из вне

LINUX-ORG-RU ★★★★★
()
Ответ на: комментарий от Lorovec

Чего ты рисуешь хоть? Заполнить экран цветом - 62 fps? Да тут в норме 6200 должно быть

deadplace
()

легко и просто манипулировать пикселями?

basic

anonymous
()

Я почитал тред и кажется понял,что хочет ТС.

1. ТС, возьми любой ЯП, где есть обвязка к SDL2 (SDL1.2 тоже сойдет, он просто старый).

2. Как тебе сказали, у тебя нет нужды писать в память непоследовательно, организуй цикл правильно.

3. Нагенерируй массив из 256 рандомных цветов.

4. Подсчитай значение x' = x * a mod 256 (возьми a каким-нибудь простым типа 53 или 13).

5. Подсчитай значение y' = y * b mod 256

6. Подсчитай i = x' + y' mod 256

7. И i' = (i^(i>>c))*d mod 256

8. Полученное число используй как индекс в массив рандомов. Если тебе ч/б надо, то i' и есть твой цвет.

9. ПРОФИТ! Такой рандом за несколько умножений, сложение и шифт куда быстрее, чем в библиотечных функциях. А может нет, лол. Но ты точно получишь 500 фпс в окне 800x600. К тому же тут нет состояния, можно распараллелить -> пару тыщ фпс в кармане. А если на GPU выгрузишь вычисления, то получишь заветные 6200 fps.

deadplace
()
Последнее исправление: deadplace (всего исправлений: 1)

Нужно примерно такое https://i.imgur.com/Yy6BNwC.png то есть короткий, легкий для понимания код.

С++:-)

из него и смайлики легко получаются :-) напиши классов/шаблонов, над SDL например, с которыми тебе просто и понятно работать.

PS/ короткий лёгкий для понимания код пишется для себя самим. На любом современном языке. Хотя г-но на них пишется гораздо проще

MKuznetsov ★★★★★
()
Ответ на: комментарий от MKuznetsov

ожидал от тебя что-то, типа:

# http://doro.poltava.ua/articles/tcl/pixane.html
lappend auto_path [file join [file dirname [info script]] ./lib]

package require pixane

set w 200
set h 100
proc RandomRange { range } {
expr int([expr rand()]*$range)
}

pixane create img
pixane resize img $w $h

pixane bgcolor img black
for {set i 0} {$i < $w} {incr i 2} {
    for {set j 0} {$j < $h} {incr j 2} {
        puts " $i  $j"
        if { [RandomRange 2] == 1 } {
            pixane color img red
            pixane plot img $j $i
        } else {
            pixane color img green
            pixane plot img $j $i
        }
    }
}

pixane color img blue
pixane rectangle img 2 2 140 35

pixane color img white
pixane text img 5 30 -font [pixfont create -file arial.ttf] -size 20 -text "Привет!"

pixane save img -format JPG -file noise2.jpg
exit

anonymous
()

Хорошо, спасибо всем за ответы. Пойду разбираться.

Lorovec
() автор топика

ТС, остановись, не слушай преждевременных оптимизаторов, разберись сначала с хотелками.

Я интересовался именно процессингом и у меня новости:

- придумал и написал этот наколенный язык для рисования не очень сильный программист (личное оценочное суждение) и сильный балабол («бла-бла, XXI век, визуальное искусство доступное каждому» - это фикция) Твои поделки в высоком разрешении и фпс никому объективно не сдались. Легкость и простота кажущаяся - как только захочешь нарисовать что-то алгоритмически сложное, то погрязнешь в сложности своих собственных строк, а не импортов и вызовов сторонних библиотек.

- идея процессинга прекрасная, но сам процессинг на джаве ненужное ненужно (это хорошая новость) Тебе тут насоветовали языков и графических либ, в чем-то они правы: пошел бы ты выучил любой нормальный язык, разобрался с массивами и циклами и т.д. с помощью библиотек научился преобразовывать массивы в картинки, отображал бы это через гуй или браузер, анимировал - подход норм, но ты потеряешь интерактивность и саму возможность накидать скетчи по-быстрому. Ради этого все задумывалось.

Я пользуюсь и могу порекламировать http://quil.info - процессинг реализованный на clojure, компилится в код для jvm или в джаваскрипт. Соединяю с джавой, мне очень удобно, оригиналу интерактивность не снилась - меняю функцию рисовки сразу вижу результат, без перезапуска программы добавляю/меняю обработчики клавиатуры и т.д.

Тебе скорее советую p5.js - визуализация данных закономерно уходит на джаваскрипт (глобальнее d3 вряд ли что-то есть) вот тебе процессинг https://editor.p5js.org/ разбирайся-запускай прямо там. Про фпс вообще не думай - 110% тебе это не требуется.

Kokonavtuz
()
Ответ на: комментарий от Kokonavtuz

Без видео Шиффмана ни p5.js ни процессинг не нужны сами по себе. А так с сообществом и видео это прекрасная возможность потыкать в алгоритмы не нагружая мозг деталями. Потом этот же код после понимания реализуется на соответствующих языках. В такой ипостаси процессинг и p5.js отличные штуки.

slapin ★★★★★
()

Это же трындец сколько импортов всяких писать!

Используй IDE, она сама импорты вставит.

bvn13 ★★★★★
()
Ответ на: комментарий от Lorovec

Это конечно C++, но дает 220fps:

#include <vector>
#include <string>
#include <random>
#include "external/raylib/src/raylib.h"

int main() {
    // Initialization
    //--------------------------------------------------------------------------------------
    const int screenWidth = 640;
    const int screenHeight = 480;

    InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");

    Image img = GenImageColor(screenWidth, screenHeight, BLACK);
    ImageFormat(&img, UNCOMPRESSED_R8G8B8A8);
    Texture2D texture = LoadTextureFromImage(img);
    std::vector<uint32_t> data;
    data.resize(screenWidth * screenHeight);
    std::mt19937 rnd{19347};
    const uint32_t black = 0xffaaaaaa;
    const uint32_t white = 0xffffffff;

    // Main game loop
    while (!WindowShouldClose()) {    // Detect window close button or ESC key
        for (int y = 0; y < screenHeight; ++y) {
            int offset = y * screenWidth;
            for (int x = 0; x < screenWidth; ++x) {
                data[offset + x] = (rnd() & 1) ? white : black;
            }
        }

        UpdateTexture(texture, data.data());
        BeginDrawing();
        DrawTexture(texture, 0, 0, WHITE);

        DrawFPS(10, 10);

        EndDrawing();
    }

    UnloadTexture(texture);
    CloseWindow();        // Close window and OpenGL context

    return 0;
}

Если rnd() заменить на x + y, то >1000. std::rand() дает 150. Но самый впечатляющий результат: 800fps я получил так:

#include <iostream>
#include <vector>
#include <string>
#include <random>
#include "external/raylib/src/raylib.h"

inline uint32_t xorshift(uint32_t x) {
    x ^= x << 13;
    x ^= x >> 17;
    x ^= x << 5;
    return x;
}

int main() {
    // Initialization
    //--------------------------------------------------------------------------------------
    const int screenWidth = 640;
    const int screenHeight = 480;

    InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");

    Image img = GenImageColor(screenWidth, screenHeight, BLACK);
    ImageFormat(&img, UNCOMPRESSED_R8G8B8A8);
    Texture2D texture = LoadTextureFromImage(img);
    std::vector<uint32_t> data;
    std::vector<uint32_t> state;
    data.resize(screenWidth * screenHeight);
    state.resize(screenWidth * screenHeight);
    std::mt19937 rnd{19347};
    for (uint32_t& x : state)
        x = rnd();

    const uint32_t black = 0xffaaaaaa;
    const uint32_t white = 0xffffffff;

    // Main game loop
    while (!WindowShouldClose()) {    // Detect window close button or ESC key
        for (size_t i = 0; i < data.size(); ++i) {
            state[i] = xorshift(state[i]);
            data[i] = (state[i] & 1) ? white : black;
        }

        UpdateTexture(texture, data.data());
        BeginDrawing();
        DrawTexture(texture, 0, 0, WHITE);

        DrawFPS(10, 10);

        EndDrawing();
    }

    UnloadTexture(texture);
    CloseWindow();        // Close window and OpenGL context

    return 0;
}

rymis ★★
()
Ответ на: комментарий от rymis

Это какая-то магия. Буду разбираться, спасибо.

Lorovec
() автор топика
Ответ на: комментарий от Kokonavtuz

оригиналу интерактивность не снилась - меняю функцию рисовки сразу вижу результат, без перезапуска программы

Если я правильно понял, то в Processing есть интерактивность: http://galsasson.com/tweakmode/

идея процессинга прекрасная, но сам процессинг на джаве ненужное ненужно

Я тоже такое подумал. Потому в оп его и упомянул, как образец того, что нужно, но не java.

Lorovec
() автор топика

Кложура. http://quil.info/
Но это обвязка над тем же процессингом.
Посмотри, может сойдёт.

Hertz ★★★★★
()

На каком яп можно так же легко и просто манипулировать пикселями?

GLSL вестимо.

jo_b1ack ★★★★★
()
Ответ на: комментарий от Lorovec

Конечно, посмотри pillow. Тысячи их на самом деле, зависит от задач.

anonymous
()
Ответ на: комментарий от slapin

С удовольствием бы все выкинул, был бы инструмент чтобы быстрее завести и включить.

Kokonavtuz
()
Ответ на: комментарий от Lorovec

Мы о разной интерактивности говорим.

Подскажи что тебе нужно и можно будет решить нужен ли тебе вообще этот процессинг на джаваскрипте, питоне или еще на чем. Люди не хотят вдруг рисовать черно-белые точки, так не бывает, не верю. Рассуждать как это лучше делать это спецолимпиада. У тебя реально другая задача, которую ты не можешь/ не хочешь сформулировать, хотя это твое дело. Какая задача максимум: максимальное разрешение, сложная функция отрисовки, просто боишься что не хватит фпс, будешь ли кому-показывать в виде кода/видео, точно ли реалтайм нужен, - влияет на выбор инструмента и сколько времени на это потратить

Kokonavtuz
()

Вот Сorange варианты (он отличается от моего форка поэтому многословно, так как перенёс тест что бы ты мог скомпилять на обычном Corange)

#include "corange.h"

typedef SDL_Event event;
static bool  running = true;
static event event_common_event = { 0 };
static bool  event_common_state = false;

inline static event event_get(){
    return  event_common_event;
}
bool event_update(){
    event_common_state = SDL_PollEvent(&event_common_event);
    return event_common_state;
}
void exit_callback(ui_button * btn,void * data){
    running = false;
}

int main(int argc, char *argv[])
{
    corange_init("../../assets_core");

    int w = graphics_viewport_width();
    int h = graphics_viewport_height();

    //--------------------------------------------------
    // create canvas area
    //--------------------------------------------------
    ui_rectangle * canvas = ui_elem_new("canvas",ui_rectangle);
    ui_rectangle_move(canvas,vec2_zero());
    //--------------------------------------------------
    // load default image (640x480) for draw canvas 
    //--------------------------------------------------
    ui_rectangle_set_texture(canvas,asset_hndl_new_load(P("./in.tga")),w,h,0);
    ui_rectangle_resize(canvas,vec2_new(w,h));
    //--------------------------------------------------
    // take image data for pain canvas
    //--------------------------------------------------
    image * ii = texture_get_image(asset_get(P("./in.tga")));
    texture * tt = asset_hndl_ptr(&canvas->texture);

    ui_button * ext = ui_elem_new("ext",ui_button);
    ui_button_set_onclick(ext,exit_callback);
    ui_button_resize(ext,vec2_new(60,30));
    ui_button_move(ext,vec2_new(w-65,5));
    ui_button_set_label(ext,"Exit");

    ui_text * fps = ui_elem_new("fps",ui_text);
    fps->active = true;
    ui_text_draw_string(fps,frame_rate_string());
    ui_text_set_color(fps,vec4_green());

    vec4 color  = vec4_blue();

    while(running)
    {
       frame_begin();
       //frame_end_at_rate(60); // unlock frame rate
       while(event_update())
       {
            ui_event(event_get());

            //--------------------------------------------------
            // Save current canvas to file
            //--------------------------------------------------
            if(event_get().key.keysym.sym == SDLK_s)
            {
                image_write_to_file(ii,"./out.tga");
            }
            //--------------------------------------------------
            // Clear Canvas
            // Take texture data write black color + alpha fill
            //--------------------------------------------------
            if(event_get().button.button == SDL_BUTTON_RIGHT)
            {
              image_fill(ii,vec4_new(0,0,0,1));
              texture_set_image(tt,ii);
            }
 
       };
           //--------------------------------------------------
           // Variant 1: ~ 30 fps 
           //--------------------------------------------------
           /*
           vec4 noise(vec4 color)
           {
              float v = randf_scale(2);// 0..2
              if(v > 1)
              {
                return vec4_new(1,1,1,1);
              }
                return vec4_new(0,0,0,1);
           }
           image_map(ii,noise);
           */

           //--------------------------------------------------
           //Variant 2: ~ 70 fps  
           //--------------------------------------------------
           /*
           for (int w = 0; w < ii->width; ++w)
           {
               for (int h = 0; h < ii->height; ++h)
               {
                   if(randf_scale(2)>1)
                   {
                        image_set(ii,w,h,vec4_new(1,1,1,1));
                   }else{
                        image_set(ii,w,h,vec4_new(0,0,0,1));
                   }
               }
           }
           */

           //--------------------------------------------------
           //Variant 3:  ~ 550 fps
           //--------------------------------------------------
           // https://stackoverflow.com/questions/1640258/need-a-fast-random-generator-for-c
            static unsigned long x=123456789, y=362436069, z=521288629;
            unsigned long xorshf96(void) {
            unsigned long t;
            x ^= x << 16;
            x ^= x >> 5;
            x ^= x << 1;

            t = x;
            x = y;
            y = z;
            z = t ^ x ^ y;

            return z;
           }

           for (int x = 0; x < (ii->width * ii->height * 4);)
           {
                int c = (xorshf96() % 2 == 0)?255:0;
                ii->data[x+0] = c; // R
                ii->data[x+1] = c; // G
                ii->data[x+2] = c; // B
                ii->data[x+3] = 255; // A
                x+=4;
           }

           //-------------------------------------------------------------------------------
           // Variant 4: GLSL Мне лень но это будет самое быстрое из в принцпе возможного =)
           // Но что бы было удобно  пользоваться надо делать обёртки что для тебя не гуд
           //-------------------------------------------------------------------------------
           
       texture_set_image(tt,ii);
       ui_text_draw_string(fps,frame_rate_string());
       ui_update();
       ui_render();
       graphics_swap();
       frame_end();
    };

    corange_finish();

    return 0;
}


Makefile

APP=noise
CC=gcc 

CFLAGS= -I../../include -std=gnu99 -Wall -Werror -Wno-unused -O3 

PLATFORM = $(shell uname)

ifeq ($(findstring Linux,$(PLATFORM)),Linux)
	OUT=$(APP)
	LFLAGS=-L../../ -lcorange -lGL -lSDL2 -lSDL2_net -lSDL2_mixer -lm
endif

ifeq ($(findstring Darwin,$(PLATFORM)),Darwin)
	OUT=$(APP)
	LFLAGS=-L../../ -lcorange -lGL -lSDL2main -lSDL2 -lSDL2_net -lSDL2_mixer
endif

ifeq ($(findstring MINGW,$(PLATFORM)),MINGW)
	OUT=$(APP).exe
	LFLAGS=-L../../ -lcorange -lmingw32 -lSDL2main -lSDL2 -lSDL2_net -lSDL2_mixer -lopengl32
endif

$(OUT): *.c
	$(CC) $< $(CFLAGS) $(LFLAGS) -o $@
	
clean:
	rm $(OUT)


LINUX-ORG-RU ★★★★★
()
Ответ на: комментарий от LINUX-ORG-RU

Скачать коранж зайтив demos сделать там каталог noise и положить внутри картинку нужного размера с именем in.tga (любого содержания) и main.c и Makefile, затем

Собрать коранж cd Corange; make -j24; rm libcorange.so

Собрать тест cd Corange/demos/noise;make;./noise

LINUX-ORG-RU ★★★★★
()
Ответ на: комментарий от Kokonavtuz

Нужен микро-аналог CorelDraw на минималках. Inkscape не нравится совсем. Например в нем границы тонких фигур просто исчезают(истончаются) при масштабировании. В кореле нет, но корел платный и на винду. Нужна чисто геометрия, почти CAD, но тоже на минималках. Некоторые CAD перебрал - нет такого удобства, как в корел и много лишнего. Я посмотрел некоторые примеры в некоторых языках(фреймворках) как рисовать, например, на canvas. И главное как перемещать уже нарисованные фигуры поверх массива нарисаванных других фигур. Часто используется метод полной перерисовки всей области или нужного фрагмента. То есть обновляется все. Потому придумал такой тест для оценки возможностей такого способа отрисовки.

Как еще можно рисовать массив фигур? И в частности перерисовывать какую-то фигуру и фон на котором другие фигуры, когда её например перетаскивают мышкой?

Lorovec
() автор топика
Ответ на: комментарий от Lorovec

Просто мне показалось, если бы я написал такое в оп, то обсуждение зашло бы немного не в ту сторону, которую мне хотелось.

Lorovec
() автор топика
Ответ на: комментарий от Lorovec

Ну, да, но можно один раз сесть и убрать всё в лишнее в обёртки и свести всё до

#include "corange.h"

init(640,480);

image * img = image_load("./in.tga");

loop()
{
    vec4 noise(vec4 color){
    if(randf_scale(2) > 1){
        return vec4_new(1,1,1,1);
    }
        return vec4_new(0,0,0,1);
    }

    image_map(img,noise);
    image_draw(img)
}
image_delete(img);
quit();

LINUX-ORG-RU ★★★★★
()
Ответ на: комментарий от Lorovec

Ты вообще не с той стороны к задаче подошёл.

Точнее, это было бы правильным подходом в 80-90-е годы. Возможно, ещё в начале двухтысячных, но точно не сейчас. Теперь для получения скорости отрисовки сцены нужно думать над тем, как её представить поудобнее для GPU. Задача отслеживать изменения в сцене и перерисовывать только отдельные пиксели просто исчезает. Этим стоило заниматься под MS-DOS компьютерами, когда доступ к видеопамяти был медленный, и любая экономия числа обновляемых пикселей давала эффект. Теперь ты потеряешь в скорости, если на GPU будешь пытаться определить, какую часть буфера нужно менять. Быстрее отрисовать вообще всё, хоть как-то влезающее в область видимости.

i-rinat ★★★★★
()
Ответ на: комментарий от LINUX-ORG-RU

vec4 это rgba в значениях от 0 до 1. Сorange это скорее фреймворк которым ты себе сам можешь написать нужный тебе инструмент, можно взять LOVE как сказали выше или raylib и также сделать очень упрощённое использование скрыв всё остальное что не требует постоянного изменения.

LINUX-ORG-RU ★★★★★
()
Ответ на: комментарий от i-rinat

… Ну да в принцпе, выше я дал пример с over 500 fps на одном ядре ЦП 2,8Гг что должно давать хороший запас на вспомогательные вычисления если ему приспичит. Блин… чёт тогда интерес уже пропал. Ну да ладно

LINUX-ORG-RU ★★★★★
()
Ответ на: комментарий от i-rinat

Гы =) Я велосипедист, а ещё я переизобретаю гуи тулкит вместо использования nuklear который даже уже встроил себе, **порицайте меня! ┌( ಠ_ಠ)┘ **, *только не бейте ʕ•ᴥ•ʔ *

LINUX-ORG-RU ★★★★★
()
Ответ на: комментарий от i-rinat

А если у него 4к монитор 240hz и он хочет фуллскрин 3840x2160px картинку обрабатывать perpixel? Тогда любая реализация на cpu будет тупо сосать начиная от того сколько надо крутить циклы даже если прикодить rgba блоки к int сократить крутилку в 4 раза, до того что итоговое нужно ещё каждый кадр загонять в текстуру, а это горлышком может стать ибо данные жирные. Тут без полной обработки на стороне GPU уже никак, хотя даже GPU например мой Radeon hd6850 тоже будет выть вертилятором от боли в попытке улететь из системного блока нахрен =)

LINUX-ORG-RU ★★★★★
()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.